protected override void UpdateData()
        {
            var geometry = (PathGeometry)Data;
            geometry.Figures.Clear();

            if (ParentMap != null && Locations != null && Locations.Any())
            {
                var points = Locations.Select(l => ParentMap.MapTransform.Transform(l));

                var figure = new PathFigure
                {
                    StartPoint = points.First(),
                    IsClosed = IsClosed,
                    IsFilled = IsClosed
                };

                var segment = new PolyLineSegment();

                foreach (var point in points.Skip(1))
                {
                    segment.Points.Add(point);
                }

                figure.Segments.Add(segment);
                geometry.Figures.Add(figure);
                geometry.Transform = ParentMap.ViewportTransform;
            }
            else
            {
                geometry.ClearValue(Geometry.TransformProperty);
            }
        }
示例#2
0
 /// <summary>
 /// Creates the part.
 /// </summary>
 /// <returns>
 /// UIElement
 /// </returns>
 public override UIElement CreatePart()
 {
     SplinePath = new Path();
     PathFigure figure = new PathFigure();
     BezierSegment bezierPoints = new BezierSegment();
     PathGeometry pathGeometry = new PathGeometry();
     figure.StartPoint = StartPoint;
     bezierPoints.Point1 = FirstControlPoint;
     bezierPoints.Point2 = EndControlPoint;
     bezierPoints.Point3 = EndPoint;
     figure.Segments.Add(bezierPoints);
     pathGeometry.Figures = new PathFigureCollection() { figure };
     SplinePath.Data = pathGeometry;
     SetBindingForStrokeandStrokeThickness(SplinePath);
     return SplinePath;
 }
示例#3
0
 /// <summary>
 /// Create a visual for single Series Part
 /// </summary>
 /// <returns>
 /// UIElement
 /// </returns>
 public override UIElement CreatePart()
 {
     AreaPath = new Path();
     PathFigure figure = new PathFigure();
     LineSegment startLineSegment = new LineSegment();
     LineSegment areaEndLineSegment = new LineSegment();
     LineSegment endLineSegment = new LineSegment();
     PathGeometry pathGeometry = new PathGeometry();
     figure.StartPoint = StartPoint;
     startLineSegment.Point = AreaStartPoint;
     endLineSegment.Point = EndPoint;
     areaEndLineSegment.Point = AreaEndPoint;
     figure.Segments.Add(startLineSegment);
     figure.Segments.Add(areaEndLineSegment);
     figure.Segments.Add(endLineSegment);
     pathGeometry.Figures = new PathFigureCollection() { figure };
     AreaPath.Data = pathGeometry;
     SetBindingForStrokeandStrokeThickness(AreaPath);
     return AreaPath;
 }
示例#4
0
        public void Arc(Canvas surface, double left, double top, double right, double bottom, double startArcX, double startArcY, double endArcX, double endArcY)
        {
            var arc = new Path();
            var figure = new PathFigure();
            var segments = new PathSegmentCollection();

            var center = new Point(left + ((right - left) / 2), top + ((bottom - top) / 2));
            double degrees = Math.Atan2(startArcY - center.Y, startArcX - center.X)
                            - Math.Atan2(endArcY - center.Y, endArcX - center.X);

            degrees *= 57.2957795; // Convert from radians to degrees
            bool isLargeArc = Math.Abs(degrees) > 180;

            arc.Data = new PathGeometry();

            figure.StartPoint = new Point(LtoDX(startArcX), LtoDY(startArcY));

            var segment = new ArcSegment
                              {
                                  Point = new Point(
                                      LtoDX(endArcX),
                                      LtoDY(endArcY)),
                                  Size = new Size(
                                      (LtoDX(right) - LtoDX(left)) / 2,
                                      (LtoDY(bottom) - LtoDY(top)) / 2),
                                  RotationAngle = 0,
                                  IsLargeArc = isLargeArc,
                                  SweepDirection = SweepDirection.Counterclockwise
                              };

            segments.Add(segment);

            figure.Segments = segments;
            ((PathGeometry)arc.Data).Figures.Add(figure);

            ApplyStyle(arc, false);

            surface.Children.Add(arc);
        }
        protected override void UpdateData()
        {
            var geometry = (PathGeometry)Data;
            var locations = Locations;
            Location first;

            if (ParentMap != null && locations != null && (first = locations.FirstOrDefault()) != null)
            {
                var figure = new PathFigure
                {
                    StartPoint = ParentMap.MapTransform.Transform(first),
                    IsClosed = IsClosed,
                    IsFilled = IsClosed
                };

                var segment = new PolyLineSegment();

                foreach (var location in locations.Skip(1))
                {
                    segment.Points.Add(ParentMap.MapTransform.Transform(location));
                }

                if (segment.Points.Count > 0)
                {
                    figure.Segments.Add(segment);
                }

                geometry.Figures.Clear();
                geometry.Figures.Add(figure);
                geometry.Transform = ParentMap.ViewportTransform;
            }
            else
            {
                geometry.Figures.Clear();
                geometry.ClearValue(Geometry.TransformProperty);
            }
        }
        /// <summary>
        /// Converts a string of Path.Data into PathGeometry. 
        /// </summary>
        /// <param name="pathStr">Path.Data in string form.</param>
        /// <returns>PathGeometry from data string</returns>
        /// <example>
        /// pathStr = "M532,181 L532,219 L571,219 L570.54004,180.9397 z";
        /// var geometry = PathUtils.ParsePathGeometryString(pathStr);
        /// ArtefactAnimator.AddEase(myPath, Path.DataProperty, geometry, 3, AnimationTransitions.CubicEaseOut, 0);
        /// </example>
        public static PathGeometry ParsePathGeometryString ( string pathStr )
        {
            // string too short or doesn't exist
            if ( pathStr == null || pathStr.Length < 2 )return new PathGeometry();

            // groups representing segments
            var matches = PathGeometryExpression.Matches(pathStr);

            // single figure holding segements
            var figure = new PathFigure
            {
                Segments = new PathSegmentCollection(), 
                StartPoint = new Point(),
                IsClosed = pathStr.Substring(pathStr.Length-1, 1).ToLower() == "z"
            };

            // final path geometry
            var pathGeo = new PathGeometry { Figures = new PathFigureCollection{figure} };

            // parse matches and put in figure
            for (var i = 0; i < matches.Count; i++) ParseMatch(figure, matches[i]);

            return pathGeo;
        }
	// Start a new figure without closing the old one.
	public void StartFigure()
			{
				// We don't do anything special with figures here.
				actualFigure = null;
			}
 /// <summary>
 /// Returns new PathFigure by easing startValue to endValue using a time percentage 0 -> 1.
 /// </summary>
 public static PathFigure EaseValue(PathFigure startValue, PathFigure endValue, double percent)
 {
     return new PathFigure
     {
        IsClosed = endValue.IsClosed, 
        IsFilled = endValue.IsFilled, 
        StartPoint = EaseValue(startValue.StartPoint, endValue.StartPoint, percent),
        Segments = EaseValue(startValue.Segments, endValue.Segments, percent)
     };
 }
示例#9
0
        /// <summary>
        /// Create and apply edge path using calculated ER parameters stored in edge
        /// </summary>
        /// <param name="useCurrentCoords">Use current vertices coordinates or final coorfinates (for.ex if move animation is active final coords will be its destination)</param>
        /// <param name="externalRoutingPoints">Provided custom routing points will be used instead of stored ones.</param>
        public void PrepareEdgePath(bool useCurrentCoords = false, Point[] externalRoutingPoints = null)
        {
            //do not calculate invisible edges
            if (Visibility != Visibility.Visible || Source == null || Target == null || ManualDrawing)
            {
                return;
            }

            var template = Template;

            if (template != null)
            {
                #region Get the inputs
                //get the size of the source
                var sourceSize = new Size
                {
                    Width  = Source.ActualWidth,
                    Height = Source.ActualHeight
                };
                if (DesignerProperties.GetIsInDesignMode(this))
                {
                    sourceSize = new Size(80, 20);
                }

                //get the position center of the source
                var sourcePos = new Point
                {
                    X = (useCurrentCoords ? GraphAreaBase.GetX(Source) : GraphAreaBase.GetFinalX(Source)) + sourceSize.Width * .5,
                    Y = (useCurrentCoords ? GraphAreaBase.GetY(Source) : GraphAreaBase.GetFinalY(Source)) + sourceSize.Height * .5
                };

                //get the size of the target
                var targetSize = new Size
                {
                    Width  = Target.ActualWidth,
                    Height = Target.ActualHeight
                };
                if (DesignerProperties.GetIsInDesignMode(this))
                {
                    targetSize = new Size(80, 20);
                }

                //get the position center of the target
                var targetPos = new Point
                {
                    X = (useCurrentCoords ? GraphAreaBase.GetX(Target) : GraphAreaBase.GetFinalX(Target)) + targetSize.Width * .5,
                    Y = (useCurrentCoords ? GraphAreaBase.GetY(Target) : GraphAreaBase.GetFinalY(Target)) + targetSize.Height * .5
                };


                //get the route informations
                var routeInformation = externalRoutingPoints == null ? (Edge as IRoutingInfo).RoutingPoints : externalRoutingPoints;
                #endregion

                //if self looped edge
                if (IsSelfLooped)
                {
                    if (!RootArea.EdgeShowSelfLooped)
                    {
                        return;
                    }
                    var          pt          = new Point(sourcePos.X + RootArea.EdgeSelfLoopCircleOffset.X - RootArea.EdgeSelfLoopCircleRadius, sourcePos.Y + RootArea.EdgeSelfLoopCircleOffset.X - RootArea.EdgeSelfLoopCircleRadius);
                    var          geo         = new EllipseGeometry(pt, RootArea.EdgeSelfLoopCircleRadius, RootArea.EdgeSelfLoopCircleRadius);
                    const double dArrowAngle = Math.PI / 2.0;
                    _arrowgeometry = new PathGeometry();
                    var aPoint = sourcePos;
                    _arrowgeometry.Figures.Add(GeometryHelper.GenerateArrow(aPoint, new Point(), new Point(), dArrowAngle));

                    _linegeometry = geo;
                    return;
                }


                var hasRouteInfo = routeInformation != null && routeInformation.Length > 1;

                //calculate source and target edge attach points
                if (RootArea != null && !hasRouteInfo && RootArea.EnableParallelEdges)
                {
                    if (SourceOffset != 0)
                    {
                        sourcePos = GetParallelOffset(Source, Target, SourceOffset);
                    }
                    if (TargetOffset != 0)
                    {
                        targetPos = GetParallelOffset(Target, Source, TargetOffset);
                    }
                }

                /* Rectangular shapes implementation by bleibold */

                // Get the TopLeft position of the Source Vertex.
                var sourcePos1 = new Point
                {
                    X = (useCurrentCoords ? GraphAreaBase.GetX(Source) : GraphAreaBase.GetFinalX(Source)),
                    Y = (useCurrentCoords ? GraphAreaBase.GetY(Source) : GraphAreaBase.GetFinalY(Source))
                };
                // Get the TopLeft position of the Target Vertex.
                var targetPos1 = new Point
                {
                    X = (useCurrentCoords ? GraphAreaBase.GetX(Target) : GraphAreaBase.GetFinalX(Target)),
                    Y = (useCurrentCoords ? GraphAreaBase.GetY(Target) : GraphAreaBase.GetFinalY(Target))
                };

                //Point p1 = GeometryHelper.GetEdgeEndpoint(sourcePos, new Rect(sourceSize), (hasRouteInfo ? routeInformation[1] : (targetPos)), Source.MathShape);
                //Point p2 = GeometryHelper.GetEdgeEndpoint(targetPos, new Rect(targetSize), hasRouteInfo ? routeInformation[routeInformation.Length - 2] : (sourcePos), Target.MathShape);

                var p1 = GeometryHelper.GetEdgeEndpoint(sourcePos, new Rect(sourcePos1, sourceSize), (hasRouteInfo ? routeInformation[1] : (targetPos)), Source.MathShape);
                var p2 = GeometryHelper.GetEdgeEndpoint(targetPos, new Rect(targetPos1, targetSize), hasRouteInfo ? routeInformation[routeInformation.Length - 2] : (sourcePos), Target.MathShape);

                _linegeometry  = new PathGeometry(); PathFigure lineFigure;
                _arrowgeometry = new PathGeometry(); PathFigure arrowFigure;

                //if we have route and route consist of 2 or more points
                if (RootArea != null && hasRouteInfo)
                {
                    //replace start and end points with accurate ones
                    var routePoints = routeInformation.ToList();
                    routePoints.Remove(routePoints.First());
                    routePoints.Remove(routePoints.Last());
                    routePoints.Insert(0, p1);
                    routePoints.Add(p2);

                    if (RootArea.EdgeCurvingEnabled)
                    {
                        var oPolyLineSegment = GeometryHelper.GetCurveThroughPoints(routePoints.ToArray(), 0.5, RootArea.EdgeCurvingTolerance);
                        lineFigure = GeometryHelper.GetPathFigureFromPathSegments(routePoints[0], true, true, oPolyLineSegment);
                        //get two last points of curved path to generate correct arrow
                        var cLast = oPolyLineSegment.Points.Last();
                        var cPrev = oPolyLineSegment.Points[oPolyLineSegment.Points.Count - 2];
                        arrowFigure = GeometryHelper.GenerateOldArrow(cPrev, cLast);
                        //freeze and create resulting geometry
                        GeometryHelper.TryFreeze(oPolyLineSegment);
                    }
                    else
                    {
                        lineFigure  = new PathFigure(p1, new PathSegment[] { new PolyLineSegment(routePoints, true) }, false);
                        arrowFigure = GeometryHelper.GenerateOldArrow(routePoints[routePoints.Count - 2], p2);
                    }
                }
                else // no route defined
                {
                    //!!! Here is the line calculation to not overlap an arrowhead
                    //Vector v = p1 - p2; v = v / v.Length * 5;
                    // Vector n = new Vector(-v.Y, v.X) * 0.7;
                    //segments[0] = new LineSegment(p2 + v, true);
                    lineFigure  = new PathFigure(p1, new PathSegment[] { new LineSegment(p2, true) }, false);
                    arrowFigure = GeometryHelper.GenerateOldArrow(p1, p2);
                }
                GeometryHelper.TryFreeze(lineFigure);
                (_linegeometry as PathGeometry).Figures.Add(lineFigure);
                if (arrowFigure != null)
                {
                    GeometryHelper.TryFreeze(arrowFigure);
                    _arrowgeometry.Figures.Add(arrowFigure);
                }
                GeometryHelper.TryFreeze(_linegeometry);
                GeometryHelper.TryFreeze(_arrowgeometry);
            }
            else
            {
                Debug.WriteLine("PrepareEdgePath() -> Edge template not found! Can't apply path to display edge!");
            }
        }
示例#10
0
        /// <summary>
        /// Creates a border geometry with a 'pointer'.
        /// </summary>
        /// <param name="ha">The horizontal alignment.</param>
        /// <param name="va">The vertical alignment.</param>
        /// <param name="width">The width.</param>
        /// <param name="height">The height.</param>
        /// <param name="margin">The margin.</param>
        /// <returns>The border geometry.</returns>
        private Geometry CreatePointerBorderGeometry(
            HorizontalAlignment ha, VerticalAlignment va, double width, double height, out Thickness margin)
        {
            Point[] points = null;
            double  m      = this.Distance;

            margin = new Thickness();

            if (ha == HorizontalAlignment.Center && va == VerticalAlignment.Bottom)
            {
                double x0 = 0;
                double x1 = width;
                double x2 = (x0 + x1) / 2;
                double y0 = 0;
                double y1 = height;
                margin = new Thickness {
                    Bottom = m
                };
                points = new[]
                {
                    new Point(x0, y0), new Point(x1, y0), new Point(x1, y1), new Point(x2 + (m / 2), y1),
                    new Point(x2, y1 + m), new Point(x2 - (m / 2), y1), new Point(x0, y1)
                };
            }

            if (ha == HorizontalAlignment.Center && va == VerticalAlignment.Top)
            {
                double x0 = 0;
                double x1 = width;
                double x2 = (x0 + x1) / 2;
                double y0 = m;
                double y1 = m + height;
                margin = new Thickness {
                    Top = m
                };
                points = new[]
                {
                    new Point(x0, y0), new Point(x2 - (m / 2), y0), new Point(x2, 0), new Point(x2 + (m / 2), y0),
                    new Point(x1, y0), new Point(x1, y1), new Point(x0, y1)
                };
            }

            if (ha == HorizontalAlignment.Left && va == VerticalAlignment.Center)
            {
                double x0 = m;
                double x1 = m + width;
                double y0 = 0;
                double y1 = height;
                double y2 = (y0 + y1) / 2;
                margin = new Thickness {
                    Left = m
                };
                points = new[]
                {
                    new Point(0, y2), new Point(x0, y2 - (m / 2)), new Point(x0, y0), new Point(x1, y0),
                    new Point(x1, y1), new Point(x0, y1), new Point(x0, y2 + (m / 2))
                };
            }

            if (ha == HorizontalAlignment.Right && va == VerticalAlignment.Center)
            {
                double x0 = 0;
                double x1 = width;
                double y0 = 0;
                double y1 = height;
                double y2 = (y0 + y1) / 2;
                margin = new Thickness {
                    Right = m
                };
                points = new[]
                {
                    new Point(x1 + m, y2), new Point(x1, y2 + (m / 2)), new Point(x1, y1), new Point(x0, y1),
                    new Point(x0, y0), new Point(x1, y0), new Point(x1, y2 - (m / 2))
                };
            }

            if (ha == HorizontalAlignment.Left && va == VerticalAlignment.Top)
            {
                m *= 0.67;
                double x0 = m;
                double x1 = m + width;
                double y0 = m;
                double y1 = m + height;
                margin = new Thickness {
                    Left = m, Top = m
                };
                points = new[]
                {
                    new Point(0, 0), new Point(m * 2, y0), new Point(x1, y0), new Point(x1, y1), new Point(x0, y1),
                    new Point(x0, m * 2)
                };
            }

            if (ha == HorizontalAlignment.Right && va == VerticalAlignment.Top)
            {
                m *= 0.67;
                double x0 = 0;
                double x1 = width;
                double y0 = m;
                double y1 = m + height;
                margin = new Thickness {
                    Top = m, Right = m
                };
                points = new[]
                {
                    new Point(x1 + m, 0), new Point(x1, y0 + m), new Point(x1, y1), new Point(x0, y1),
                    new Point(x0, y0), new Point(x1 - m, y0)
                };
            }

            if (ha == HorizontalAlignment.Left && va == VerticalAlignment.Bottom)
            {
                m *= 0.67;
                double x0 = m;
                double x1 = m + width;
                double y0 = 0;
                double y1 = height;
                margin = new Thickness {
                    Left = m, Bottom = m
                };
                points = new[]
                {
                    new Point(0, y1 + m), new Point(x0, y1 - m), new Point(x0, y0), new Point(x1, y0),
                    new Point(x1, y1), new Point(x0 + m, y1)
                };
            }

            if (ha == HorizontalAlignment.Right && va == VerticalAlignment.Bottom)
            {
                m *= 0.67;
                double x0 = 0;
                double x1 = width;
                double y0 = 0;
                double y1 = height;
                margin = new Thickness {
                    Right = m, Bottom = m
                };
                points = new[]
                {
                    new Point(x1 + m, y1 + m), new Point(x1 - m, y1), new Point(x0, y1), new Point(x0, y0),
                    new Point(x1, y0), new Point(x1, y1 - m)
                };
            }

            if (points == null)
            {
                return(null);
            }

            var pointCollection = new PointCollection();

            foreach (var point in points)
            {
                pointCollection.Add(point);
            }

            var segments = new PathSegmentCollection {
                new PolyLineSegment {
                    Points = pointCollection
                }
            };
            var pf = new PathFigure {
                StartPoint = points[0], Segments = segments, IsClosed = true
            };

            return(new PathGeometry {
                Figures = new PathFigureCollection {
                    pf
                }
            });
        }
示例#11
0
        /// <summary>
        /// Creates a border geometry with a 'pointer'.
        /// </summary>
        /// <param name="ha">The horizontal alignment.</param>
        /// <param name="va">The vertical alignment.</param>
        /// <param name="width">The width.</param>
        /// <param name="height">The height.</param>
        /// <param name="margin">The margin.</param>
        /// <returns>The border geometry.</returns>
        private Geometry CreatePointerBorderGeometry(
            HorizontalAlignment ha, VerticalAlignment va, double width, double height, out Thickness margin)
        {
            Point[] points = null;
            double m = this.Distance;
            margin = new Thickness();

            if (ha == HorizontalAlignment.Center && va == VerticalAlignment.Bottom)
            {
                double x0 = 0;
                double x1 = width;
                double x2 = (x0 + x1) / 2;
                double y0 = 0;
                double y1 = height;
                margin = new Thickness { Bottom = m };
                points = new[]
                    {
                        new Point(x0, y0), new Point(x1, y0), new Point(x1, y1), new Point(x2 + (m / 2), y1),
                        new Point(x2, y1 + m), new Point(x2 - (m / 2), y1), new Point(x0, y1)
                    };
            }

            if (ha == HorizontalAlignment.Center && va == VerticalAlignment.Top)
            {
                double x0 = 0;
                double x1 = width;
                double x2 = (x0 + x1) / 2;
                double y0 = m;
                double y1 = m + height;
                margin = new Thickness { Top = m };
                points = new[]
                    {
                        new Point(x0, y0), new Point(x2 - (m / 2), y0), new Point(x2, 0), new Point(x2 + (m / 2), y0),
                        new Point(x1, y0), new Point(x1, y1), new Point(x0, y1)
                    };
            }

            if (ha == HorizontalAlignment.Left && va == VerticalAlignment.Center)
            {
                double x0 = m;
                double x1 = m + width;
                double y0 = 0;
                double y1 = height;
                double y2 = (y0 + y1) / 2;
                margin = new Thickness { Left = m };
                points = new[]
                    {
                        new Point(0, y2), new Point(x0, y2 - (m / 2)), new Point(x0, y0), new Point(x1, y0),
                        new Point(x1, y1), new Point(x0, y1), new Point(x0, y2 + (m / 2))
                    };
            }

            if (ha == HorizontalAlignment.Right && va == VerticalAlignment.Center)
            {
                double x0 = 0;
                double x1 = width;
                double y0 = 0;
                double y1 = height;
                double y2 = (y0 + y1) / 2;
                margin = new Thickness { Right = m };
                points = new[]
                    {
                        new Point(x1 + m, y2), new Point(x1, y2 + (m / 2)), new Point(x1, y1), new Point(x0, y1),
                        new Point(x0, y0), new Point(x1, y0), new Point(x1, y2 - (m / 2))
                    };
            }

            if (ha == HorizontalAlignment.Left && va == VerticalAlignment.Top)
            {
                m *= 0.67;
                double x0 = m;
                double x1 = m + width;
                double y0 = m;
                double y1 = m + height;
                margin = new Thickness { Left = m, Top = m };
                points = new[]
                    {
                        new Point(0, 0), new Point(m * 2, y0), new Point(x1, y0), new Point(x1, y1), new Point(x0, y1),
                        new Point(x0, m * 2)
                    };
            }

            if (ha == HorizontalAlignment.Right && va == VerticalAlignment.Top)
            {
                m *= 0.67;
                double x0 = 0;
                double x1 = width;
                double y0 = m;
                double y1 = m + height;
                margin = new Thickness { Top = m, Right = m };
                points = new[]
                    {
                        new Point(x1 + m, 0), new Point(x1, y0 + m), new Point(x1, y1), new Point(x0, y1),
                        new Point(x0, y0), new Point(x1 - m, y0)
                    };
            }

            if (ha == HorizontalAlignment.Left && va == VerticalAlignment.Bottom)
            {
                m *= 0.67;
                double x0 = m;
                double x1 = m + width;
                double y0 = 0;
                double y1 = height;
                margin = new Thickness { Left = m, Bottom = m };
                points = new[]
                    {
                        new Point(0, y1 + m), new Point(x0, y1 - m), new Point(x0, y0), new Point(x1, y0),
                        new Point(x1, y1), new Point(x0 + m, y1)
                    };
            }

            if (ha == HorizontalAlignment.Right && va == VerticalAlignment.Bottom)
            {
                m *= 0.67;
                double x0 = 0;
                double x1 = width;
                double y0 = 0;
                double y1 = height;
                margin = new Thickness { Right = m, Bottom = m };
                points = new[]
                    {
                        new Point(x1 + m, y1 + m), new Point(x1 - m, y1), new Point(x0, y1), new Point(x0, y0),
                        new Point(x1, y0), new Point(x1, y1 - m)
                    };
            }

            if (points == null)
            {
                return null;
            }

            var pointCollection = new PointCollection();
            foreach (var point in points)
            {
                pointCollection.Add(point);
            }

            var segments = new PathSegmentCollection { new PolyLineSegment { Points = pointCollection } };
            var pf = new PathFigure { StartPoint = points[0], Segments = segments, IsClosed = true };
            return new PathGeometry { Figures = new PathFigureCollection { pf } };
        }
示例#12
0
        /// <summary>
        /// Draws the multiple line segments defined by points (0,1) (2,3) (4,5) etc.
        /// This should have better performance than calling DrawLine for each segment.
        /// </summary>
        /// <param name="points">The points.</param>
        /// <param name="stroke">The stroke color.</param>
        /// <param name="thickness">The stroke thickness.</param>
        /// <param name="dashArray">The dash array.</param>
        /// <param name="lineJoin">The line join type.</param>
        /// <param name="aliased">if set to <c>true</c> the shape will be aliased.</param>
        public void DrawLineSegments(
            IList<ScreenPoint> points,
            OxyColor stroke,
            double thickness,
            double[] dashArray,
            LineJoin lineJoin,
            bool aliased)
        {
            var path = new Path();
            this.SetStroke(path, stroke, thickness, lineJoin, dashArray, aliased);
            var pg = new PathGeometry();
            for (int i = 0; i + 1 < points.Count; i += 2)
            {
                // if (points[i].Y==points[i+1].Y)
                // {
                // var line = new Line();

                // line.X1 = 0.5+(int)points[i].X;
                // line.X2 = 0.5+(int)points[i+1].X;
                // line.Y1 = 0.5+(int)points[i].Y;
                // line.Y2 = 0.5+(int)points[i+1].Y;
                // SetStroke(line, OxyColors.DarkRed, thickness, lineJoin, dashArray, aliased);
                // Add(line);
                // continue;
                // }
                var figure = new PathFigure { StartPoint = points[i].ToPoint(aliased), IsClosed = false };
                figure.Segments.Add(new LineSegment { Point = points[i + 1].ToPoint(aliased) });
                pg.Figures.Add(figure);
            }

            path.Data = pg;
            this.Add(path);
        }
示例#13
0
        public override void OnSeriesUpdateStart()
        {
            ActiveSplitters = 0;

            if (SplittersCollector == int.MaxValue - 1)
            {
                //just in case!
                Splitters.ForEach(s => s.SplitterCollectorIndex = 0);
                SplittersCollector = 0;
            }

            SplittersCollector++;

            if (Figure != null && Values != null)
            {
                var yIni = ChartFunctions.ToDrawMargin(Values.Limit2.Min, AxisOrientation.Y, Model.Chart, ScalesYAt);

                if (Model.Chart.View.DisableAnimations)
                {
                    Figure.StartPoint = new Point(0, yIni);
                }
                else
                {
                    Figure.BeginAnimation(PathFigure.StartPointProperty,
                                          new PointAnimation(new Point(0, yIni),
                                                             Model.Chart.View.AnimationsSpeed));
                }
            }

            if (IsPathInitialized)
            {
                return;
            }

            IsPathInitialized = true;

            Path = new Path();
            BindingOperations.SetBinding(Path, Shape.StrokeProperty,
                                         new Binding {
                Path = new PropertyPath("Stroke"), Source = this
            });
            BindingOperations.SetBinding(Path, Shape.FillProperty,
                                         new Binding {
                Path = new PropertyPath("Fill"), Source = this
            });
            BindingOperations.SetBinding(Path, Shape.StrokeThicknessProperty,
                                         new Binding {
                Path = new PropertyPath("StrokeThickness"), Source = this
            });
            BindingOperations.SetBinding(Path, VisibilityProperty,
                                         new Binding {
                Path = new PropertyPath("Visibility"), Source = this
            });
            BindingOperations.SetBinding(Path, Panel.ZIndexProperty,
                                         new Binding {
                Path = new PropertyPath(Panel.ZIndexProperty), Source = this
            });
            BindingOperations.SetBinding(Path, Shape.StrokeDashArrayProperty,
                                         new Binding {
                Path = new PropertyPath(StrokeDashArrayProperty), Source = this
            });
            var geometry = new PathGeometry();

            Figure = new PathFigure();
            geometry.Figures.Add(Figure);
            Path.Data = geometry;
            Model.Chart.View.AddToDrawMargin(Path);

            var y = ChartFunctions.ToDrawMargin(ActualValues.Limit2.Min, AxisOrientation.Y, Model.Chart, ScalesYAt);

            Figure.StartPoint = new Point(0, y);
        }
示例#14
0
        public void PolyPolygon(Canvas surface, IEnumerable<IEnumerable<Point>> vertices)
        {
            var polyPath = new Path();

            #if NETFX_CORE
            var geometry = new PathGeometry();

            foreach (var polygon in vertices)
            {
                var pointIndex = 0;
                var figure = new PathFigure();

                geometry.Figures.Add(figure);

                foreach (Point item in polygon)
                {
                    if (pointIndex == 0)
                    {
                        // Move to
                        figure.IsFilled = true;
                        figure.IsClosed = true;
                        figure.StartPoint = new Point(LtoDX(item.X), LtoDY(item.Y));
                    }
                    else
                    {
                        figure.Segments.Add(
                            new LineSegment()
                            {
                                Point = new Point(LtoDX(item.X), LtoDY(item.Y))
                            }
                        );
                    }

                    pointIndex++;
                }
            }
            #else
            var geometry = new StreamGeometry();

            using (StreamGeometryContext ctx = geometry.Open())
            {
                foreach (var polygon in vertices)
                {
                    var pointIndex = 0;

                    foreach (Point item in polygon)
                    {
                        if (pointIndex == 0)
                        {
                            // Move to
                            ctx.BeginFigure(new Point(LtoDX(item.X), LtoDY(item.Y)), true, true);
                        }
                        else
                        {
                            ctx.LineTo(new Point(LtoDX(item.X), LtoDY(item.Y)), true, false);
                        }

                        pointIndex++;
                    }
                }
            }
            #endif

            if (_currentState.PolyFillMode == PolyFillMode.WINDING)
            {
                geometry.FillRule = FillRule.Nonzero;
            }

            #if !NETFX_CORE
            geometry.Freeze();
            #endif

            polyPath.Data = geometry;

            #if !NETFX_CORE
            // Clip
            var clipGeometry = GetClipGeometry(geometry.Bounds);

            if (clipGeometry != null)
            {
                polyPath.Data = Geometry.Combine(polyPath.Data, clipGeometry, GeometryCombineMode.Intersect, null);
            }
            #endif

            ApplyStyle(polyPath, true);

            surface.Children.Add(polyPath);
        }
示例#15
0
        internal void PaintTrend()
        {
            if (_properties == null || _properties.Chart == null || double.IsNaN(ActualWidth) ||
                string.IsNullOrEmpty(_properties.Chart.Symbol) ||
                _updatingChart)
            {
                return;
            }

            EnsureVisualsCreated();

            _backgroundTrend.Width  = ActualWidth;
            _backgroundTrend.Height = ActualHeight;

            PathGeometry          geometry = new PathGeometry();
            PathSegmentCollection segments = new PathSegmentCollection();
            PathFigure            figure   = new PathFigure();

            Series closeSeries = _properties.Chart.SeriesCollection.FirstOrDefault(_ => _.OHLCType == SeriesTypeOHLC.Close) ??
                                 _properties.Chart.SeriesCollection.FirstOrDefault();

            if (closeSeries == null)
            {
                return;
            }

            IList <double> values = closeSeries
                                    .AllValues
                                    .Where(_ => _ != null)
                                    .Select(_ => _.Value)
                                    .ToList();

            double min = double.MaxValue;
            double max = double.MinValue;

            foreach (double value in values) // No LINQ here!!!
            {
                min = Math.Min(min, value);
                max = Math.Max(max, value);
            }

            int    i;
            double y, x;

            for (i = 0; i < values.Count; i += 5)
            {
                double value = values[i];
                x = (i * 1f / values.Count) * ActualWidth;
                if (min != max)
                {
                    y = ActualHeight * (1f - ((value - min) / (max - min)));
                }
                else
                {
                    y = ActualHeight * 0.5;
                }

                if (i == 0)
                {
                    figure.StartPoint = new Point(x, y);
                }
                else
                {
                    segments.Add(new LineSegment {
                        Point = new Point(x, y)
                    });
                }
            }

            x = ActualWidth;
            if (min != max && values.Count > 0)
            {
                y = ActualHeight * (1f - ((values[values.Count - 1] - min) / (max - min)));
            }
            else
            {
                y = ActualHeight * 0.5;
            }

            segments.Add(new LineSegment {
                Point = new Point(x, y)
            });

            segments.Add(new LineSegment {
                Point = new Point(ActualWidth, ActualHeight)
            });
            segments.Add(new LineSegment {
                Point = new Point(0, ActualHeight)
            });

            figure.Segments = segments;
            geometry.Figures.Add(figure);

            _backgroundTrend.Data = geometry;
        }
示例#16
0
        /// <summary>
        /// 绘制色环
        /// </summary>
        /// <param name="centerX">圆心坐标X点</param>
        /// <param name="centerY">圆心坐标Y点</param>
        /// <param name="radiusMax">外径</param>
        /// <param name="radiusMin">内径</param>
        private void DrawColorWheel(Double centerX, Double centerY, Double radiusMax, Double radiusMin, byte a)
        {
            // 创建绘图容器
            Grid colorWheel = new Grid()
            {
                Name = "xColorWheel"
            };

            colorWheel.Children.Clear();
            // 生成色环表
            List <Color> wheelColors = new List <Color>();

            for (byte i = 0; i < 255; i++)
            {
                wheelColors.Add(Color.FromArgb(a, 255, i, 0));
            }
            for (byte i = 255; i > 0; i--)
            {
                wheelColors.Add(Color.FromArgb(a, i, 255, 0));
            }
            for (byte i = 0; i < 255; i++)
            {
                wheelColors.Add(Color.FromArgb(a, 0, 255, i));
            }
            for (byte i = 255; i > 0; i--)
            {
                wheelColors.Add(Color.FromArgb(a, 0, i, 255));
            }
            for (byte i = 0; i < 255; i++)
            {
                wheelColors.Add(Color.FromArgb(a, i, 0, 255));
            }
            for (byte i = 255; i > 0; i--)
            {
                wheelColors.Add(Color.FromArgb(a, 255, 0, i));
            }
            // 创建路径变量
            int    colorCount = wheelColors.Count;  // 颜色数量
            Double angel = 360.0 / colorCount;      // 计算夹角(注:计算参数必须为浮点数,否则结果为0)
            Double rotate = 0;                      // 起始角度
            Double pointX, pointY;                  // 缓存绘图路径点

            // 计算绘图路径
            wheelColors.ForEach((color) =>
            {
                pointX       = centerX + radiusMax * Math.Cos(rotate * Math.PI / 180);
                pointY       = centerY + radiusMax * Math.Sin(rotate * Math.PI / 180);
                Point point0 = new Point(pointX, pointY);
                pointX       = centerX + radiusMin * Math.Cos(rotate * Math.PI / 180);
                pointY       = centerY + radiusMin * Math.Sin(rotate * Math.PI / 180);
                Point point1 = new Point(pointX, pointY);
                rotate      += angel;
                pointX       = centerX + radiusMin * Math.Cos(rotate * Math.PI / 180);
                pointY       = centerY + radiusMin * Math.Sin(rotate * Math.PI / 180);
                Point point2 = new Point(pointX, pointY);
                pointX       = centerX + radiusMax * Math.Cos(rotate * Math.PI / 180);
                pointY       = centerY + radiusMax * Math.Sin(rotate * Math.PI / 180);
                Point point3 = new Point(pointX, pointY);

                PathFigure wheelPath = new PathFigure()
                {
                    IsClosed = true, StartPoint = point0
                };
                wheelPath.Segments.Add(new LineSegment()
                {
                    Point = point1
                });
                wheelPath.Segments.Add(new ArcSegment()
                {
                    Point = point2, SweepDirection = SweepDirection.Clockwise, Size = new Size(radiusMin, radiusMin)
                });
                wheelPath.Segments.Add(new LineSegment()
                {
                    Point = point3
                });
                wheelPath.Segments.Add(new ArcSegment()
                {
                    Point = point0, Size = new Size(radiusMax, radiusMax)
                });

                PathGeometry wheelPaths          = new PathGeometry();
                PathFigureCollection pathFigures = new PathFigureCollection();
                pathFigures.Add(wheelPath);
                wheelPaths.Figures = pathFigures;
                WheelPath          = new Path()
                {
                    StrokeThickness = 0, Fill = new SolidColorBrush(color), Data = wheelPaths
                };
                colorWheel.Children.Add(WheelPath);
            });
            colorWheel.HorizontalAlignment = HorizontalAlignment.Center;
            colorWheel.VerticalAlignment   = VerticalAlignment.Center;
            colorWheel.AllowDrop           = true;
            grid.Children.Add(colorWheel);

            Canvas.SetLeft(ellipse, centerX / 2 - 5);
            Canvas.SetTop(ellipse, centerY / 2);

            Point point = new Point()
            {
                X = centerX, Y = centerY
            };
            double redius = (radiusMax - radiusMin) / 2 + radiusMin;
            var    p      = GetPoints(point, (int)redius, 100);

            Canvas.SetLeft(BlackEllipse, p[0].X - 15);
            Canvas.SetTop(BlackEllipse, p[0].Y - 15);
        }
示例#17
0
        protected override void OnRender(DrawingContext drawingContext)
        {
            if (TextView == null || !TextView.VisualLinesValid)
            {
                return;
            }

            Brush insertBrush = Theme.GetBrush(Theme.Source.DiffInsert);
            Brush removeBrush = Theme.GetBrush(Theme.Source.DiffRemove);
            Brush changeBrush = Theme.GetBrush(Theme.Source.DiffChange);

            IEnumerable <(VisualLine, int)> visualLines = TextView
                                                          .VisualLines
                                                          .Select(x => (x, x.FirstDocumentLine.LineNumber));

            List <(int number, double y, double height)> lines
                = new List <(int, double, double)>();

            foreach (VisualLine line in TextView.VisualLines)
            {
                int number = line.FirstDocumentLine.LineNumber;
                if (number >= _margin.Count)
                {
                    continue;
                }

                double y = line.GetTextLineVisualYPosition(
                    line.TextLines[0], VisualYPosition.LineTop);
                y -= TextView.VerticalOffset;

                double height = line.Height;

                lines.Add((number, y, height));
            }

            double width = RenderSize.Width;

            foreach ((int number, double y, double height) in lines)
            {
                Brush brush;
                switch (_margin[number].Kind)
                {
                case DiffMarginKind.Insert: brush = insertBrush; break;

                case DiffMarginKind.Change: brush = changeBrush; break;

                default: continue;
                }

                if (brush != null)
                {
                    Rect rect = new Rect(0, y, width, height);
                    drawingContext.DrawRectangle(brush, null, rect);
                }
            }

            foreach ((int number, double y, double height) in lines)
            {
                if (_margin[number].RemoveCount > 0)
                {
                    // I'd like to think that there is an easier way to
                    // draw a triangle than all this, but I do not see one.
                    Point top    = new Point(0, y + 0.8 * height);
                    Point middle = new Point(width, y + height);
                    Point bottom = new Point(0, y + 1.2 * height);

                    PathFigure figure = new PathFigure(top,
                                                       new PathSegment[] {
                        new LineSegment(middle, true),
                        new LineSegment(bottom, true)
                    },
                                                       closed: true
                                                       );

                    PathGeometry geometry = new PathGeometry();
                    geometry.Figures.Add(figure);

                    Pen pen = new Pen(removeBrush, 2);
                    drawingContext.DrawGeometry(removeBrush, pen, geometry);
                }
            }
        }
示例#18
0
        private void RenderTheme(DrawingContext dc)
        {
            ThemeColor        themeColor    = ThemeColor;
            Size              size          = RenderSize;
            bool              horizontal    = Orientation == Orientation.Horizontal;
            bool              isClickable   = IsClickable && IsEnabled;
            bool              isHovered     = isClickable && IsHovered;
            bool              isPressed     = isClickable && IsPressed;
            ListSortDirection?sortDirection = SortDirection;
            bool              isSorted      = sortDirection != null;
            bool              isSelected    = IsSelected;

            EnsureCache((int)LunaFreezables.NumFreezables);

            if (horizontal)
            {
                // When horizontal, rotate the rendering by -90 degrees
                Matrix m1 = new Matrix();
                m1.RotateAt(-90.0, 0.0, 0.0);
                Matrix m2 = new Matrix();
                m2.Translate(0.0, size.Height);

                MatrixTransform horizontalRotate = new MatrixTransform(m1 * m2);
                horizontalRotate.Freeze();
                dc.PushTransform(horizontalRotate);

                double temp = size.Width;
                size.Width  = size.Height;
                size.Height = temp;
            }

            // Draw the background
            LunaFreezables      backgroundType = isPressed ? LunaFreezables.PressedBackground : isHovered ? LunaFreezables.HoveredBackground : LunaFreezables.NormalBackground;
            LinearGradientBrush background     = (LinearGradientBrush)GetCachedFreezable((int)backgroundType);

            if (background == null)
            {
                background            = new LinearGradientBrush();
                background.StartPoint = new Point();
                background.EndPoint   = new Point(0.0, 1.0);

                if (isPressed)
                {
                    if (themeColor == ThemeColor.Metallic)
                    {
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xB9, 0xB9, 0xC8), 0.0));
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xEC, 0xF3), 0.1));
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xEC, 0xF3), 1.0));
                    }
                    else
                    {
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xC1, 0xC2, 0xB8), 0.0));
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDE, 0xDF, 0xD8), 0.1));
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDE, 0xDF, 0xD8), 1.0));
                    }
                }
                else if (isHovered || isSelected)
                {
                    if (themeColor == ThemeColor.Metallic)
                    {
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFE, 0xFE, 0xFE), 0.0));
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFE, 0xFE, 0xFE), 0.85));
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xBD, 0xBE, 0xCE), 1.0));
                    }
                    else
                    {
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFA, 0xF9, 0xF4), 0.0));
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFA, 0xF9, 0xF4), 0.85));
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEC, 0xE9, 0xD8), 1.0));
                    }
                }
                else
                {
                    if (themeColor == ThemeColor.Metallic)
                    {
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xF9, 0xFA, 0xFD), 0.0));
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xF9, 0xFA, 0xFD), 0.85));
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xBD, 0xBE, 0xCE), 1.0));
                    }
                    else
                    {
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEB, 0xEA, 0xDB), 0.0));
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xEB, 0xEA, 0xDB), 0.85));
                        background.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xCB, 0xC7, 0xB8), 1.0));
                    }
                }

                background.Freeze();
                CacheFreezable(background, (int)backgroundType);
            }

            dc.DrawRectangle(background, null, new Rect(0.0, 0.0, size.Width, size.Height));

            if (isHovered && !isPressed && (size.Width >= 6.0) && (size.Height >= 4.0))
            {
                // When hovered, there is a colored tab at the bottom
                TranslateTransform positionTransform = new TranslateTransform(0.0, size.Height - 3.0);
                positionTransform.Freeze();
                dc.PushTransform(positionTransform);

                PathGeometry tabGeometry = new PathGeometry();
                PathFigure   tabFigure   = new PathFigure();

                tabFigure.StartPoint = new Point(0.5, 0.5);

                LineSegment line = new LineSegment(new Point(size.Width - 0.5, 0.5), true);
                line.Freeze();
                tabFigure.Segments.Add(line);

                ArcSegment arc = new ArcSegment(new Point(size.Width - 2.5, 2.5), new Size(2.0, 2.0), 90.0, false, SweepDirection.Clockwise, true);
                arc.Freeze();
                tabFigure.Segments.Add(arc);

                line = new LineSegment(new Point(2.5, 2.5), true);
                line.Freeze();
                tabFigure.Segments.Add(line);

                arc = new ArcSegment(new Point(0.5, 0.5), new Size(2.0, 2.0), 90.0, false, SweepDirection.Clockwise, true);
                arc.Freeze();
                tabFigure.Segments.Add(arc);

                tabFigure.IsClosed = true;
                tabFigure.Freeze();

                tabGeometry.Figures.Add(tabFigure);
                tabGeometry.Freeze();

                Pen tabStroke = (Pen)GetCachedFreezable((int)LunaFreezables.TabStroke);
                if (tabStroke == null)
                {
                    SolidColorBrush tabStrokeBrush = new SolidColorBrush((themeColor == ThemeColor.Homestead) ? Color.FromArgb(0xFF, 0xCF, 0x72, 0x25) : Color.FromArgb(0xFF, 0xF8, 0xA9, 0x00));
                    tabStrokeBrush.Freeze();

                    tabStroke = new Pen(tabStrokeBrush, 1.0);
                    tabStroke.Freeze();

                    CacheFreezable(tabStroke, (int)LunaFreezables.TabStroke);
                }

                LinearGradientBrush tabFill = (LinearGradientBrush)GetCachedFreezable((int)LunaFreezables.TabFill);
                if (tabFill == null)
                {
                    tabFill            = new LinearGradientBrush();
                    tabFill.StartPoint = new Point();
                    tabFill.EndPoint   = new Point(1.0, 0.0);
                    if (themeColor == ThemeColor.Homestead)
                    {
                        tabFill.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE3, 0x91, 0x4F), 0.0));
                        tabFill.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xE3, 0x91, 0x4F), 1.0));
                    }
                    else
                    {
                        tabFill.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xFC, 0xE0, 0xA6), 0.0));
                        tabFill.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xF6, 0xC4, 0x56), 0.1));
                        tabFill.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xF6, 0xC4, 0x56), 0.9));
                        tabFill.GradientStops.Add(new GradientStop(Color.FromArgb(0xFF, 0xDF, 0x97, 0x00), 1.0));
                    }

                    tabFill.Freeze();
                    CacheFreezable(tabFill, (int)LunaFreezables.TabFill);
                }

                dc.DrawGeometry(tabFill, tabStroke, tabGeometry);

                dc.Pop(); // Translate Transform
            }

            if (isPressed && (size.Width >= 2.0) && (size.Height >= 2.0))
            {
                // When pressed, there is a border on the left and bottom
                SolidColorBrush border = (SolidColorBrush)GetCachedFreezable((int)LunaFreezables.PressedBorder);
                if (border == null)
                {
                    border = new SolidColorBrush((themeColor == ThemeColor.Metallic) ? Color.FromArgb(0xFF, 0x80, 0x80, 0x99) : Color.FromArgb(0xFF, 0xA5, 0xA5, 0x97));
                    border.Freeze();
                    CacheFreezable(border, (int)LunaFreezables.PressedBorder);
                }

                dc.DrawRectangle(border, null, new Rect(0.0, 0.0, 1.0, size.Height));
                dc.DrawRectangle(border, null, new Rect(0.0, Max0(size.Height - 1.0), size.Width, 1.0));
            }

            if (!isPressed && !isHovered && (size.Width >= 4.0))
            {
                if (SeparatorVisibility == Visibility.Visible)
                {
                    Brush sideBrush;
                    if (SeparatorBrush != null)
                    {
                        sideBrush = SeparatorBrush;
                    }
                    else
                    {
                        // When not pressed or hovered, draw the resize gripper
                        LinearGradientBrush gripper = (LinearGradientBrush)GetCachedFreezable((int)(horizontal ? LunaFreezables.HorizontalGripper : LunaFreezables.VerticalGripper));
                        if (gripper == null)
                        {
                            gripper            = new LinearGradientBrush();
                            gripper.StartPoint = new Point();
                            gripper.EndPoint   = new Point(1.0, 0.0);

                            Color highlight = Color.FromArgb(0xFF, 0xFF, 0xFF, 0xFF);
                            Color shadow    = Color.FromArgb(0xFF, 0xC7, 0xC5, 0xB2);

                            if (horizontal)
                            {
                                gripper.GradientStops.Add(new GradientStop(highlight, 0.0));
                                gripper.GradientStops.Add(new GradientStop(highlight, 0.25));
                                gripper.GradientStops.Add(new GradientStop(shadow, 0.75));
                                gripper.GradientStops.Add(new GradientStop(shadow, 1.0));
                            }
                            else
                            {
                                gripper.GradientStops.Add(new GradientStop(shadow, 0.0));
                                gripper.GradientStops.Add(new GradientStop(shadow, 0.25));
                                gripper.GradientStops.Add(new GradientStop(highlight, 0.75));
                                gripper.GradientStops.Add(new GradientStop(highlight, 1.0));
                            }

                            gripper.Freeze();
                            CacheFreezable(gripper, (int)(horizontal ? LunaFreezables.HorizontalGripper : LunaFreezables.VerticalGripper));
                        }

                        sideBrush = gripper;
                    }

                    dc.DrawRectangle(sideBrush, null, new Rect(horizontal ? 0.0 : Max0(size.Width - 2.0), 4.0, 2.0, Max0(size.Height - 8.0)));
                }
            }

            if (isSorted && (size.Width > 14.0) && (size.Height > 10.0))
            {
                // When sorted, draw an arrow on the right
                TranslateTransform positionTransform = new TranslateTransform(size.Width - 15.0, (size.Height - 5.0) * 0.5);
                positionTransform.Freeze();
                dc.PushTransform(positionTransform);

                bool         ascending     = (sortDirection == ListSortDirection.Ascending);
                PathGeometry arrowGeometry = (PathGeometry)GetCachedFreezable(ascending ? (int)LunaFreezables.ArrowUpGeometry : (int)LunaFreezables.ArrowDownGeometry);
                if (arrowGeometry == null)
                {
                    arrowGeometry = new PathGeometry();
                    PathFigure arrowFigure = new PathFigure();

                    if (ascending)
                    {
                        arrowFigure.StartPoint = new Point(0.0, 5.0);

                        LineSegment line = new LineSegment(new Point(5.0, 0.0), false);
                        line.Freeze();
                        arrowFigure.Segments.Add(line);

                        line = new LineSegment(new Point(10.0, 5.0), false);
                        line.Freeze();
                        arrowFigure.Segments.Add(line);
                    }
                    else
                    {
                        arrowFigure.StartPoint = new Point(0.0, 0.0);

                        LineSegment line = new LineSegment(new Point(10.0, 0.0), false);
                        line.Freeze();
                        arrowFigure.Segments.Add(line);

                        line = new LineSegment(new Point(5.0, 5.0), false);
                        line.Freeze();
                        arrowFigure.Segments.Add(line);
                    }

                    arrowFigure.IsClosed = true;
                    arrowFigure.Freeze();

                    arrowGeometry.Figures.Add(arrowFigure);
                    arrowGeometry.Freeze();

                    CacheFreezable(arrowGeometry, ascending ? (int)LunaFreezables.ArrowUpGeometry : (int)LunaFreezables.ArrowDownGeometry);
                }

                SolidColorBrush arrowFill = (SolidColorBrush)GetCachedFreezable((int)LunaFreezables.ArrowFill);
                if (arrowFill == null)
                {
                    arrowFill = new SolidColorBrush(Color.FromArgb(0xFF, 0xAC, 0xA8, 0x99));
                    arrowFill.Freeze();
                    CacheFreezable(arrowFill, (int)LunaFreezables.ArrowFill);
                }

                dc.DrawGeometry(arrowFill, null, arrowGeometry);

                dc.Pop(); // Position Transform
            }

            if (horizontal)
            {
                dc.Pop(); // Horizontal Rotate
            }
        }
示例#19
0
        private void VM_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == nameof(TraceMapViewModel.Points))
            {
                var points = VM.Points;

                // Поиск минимумов и максимумов
                var maxPoint = points.Length > 1 ? points[0] : new Point(0, 0);
                var minPoint = points.Length > 1 ? points[0] : new Point(0, 0);
                foreach (var point in points)
                {
                    if (point.X < minPoint.X)
                    {
                        minPoint.X = point.X;
                    }
                    if (point.Y < minPoint.Y)
                    {
                        minPoint.Y = point.Y;
                    }
                    if (point.X > maxPoint.X)
                    {
                        maxPoint.X = point.X;
                    }
                    if (point.Y > maxPoint.Y)
                    {
                        maxPoint.Y = point.Y;
                    }
                }
                foreach (var point in MainVM.Model.Points)
                {
                    if (point.X < minPoint.X)
                    {
                        minPoint.X = point.X;
                    }
                    if (point.Y < minPoint.Y)
                    {
                        minPoint.Y = point.Y;
                    }
                    if (point.X > maxPoint.X)
                    {
                        maxPoint.X = point.X;
                    }
                    if (point.Y > maxPoint.Y)
                    {
                        maxPoint.Y = point.Y;
                    }
                }

                const int padding    = 10;
                const int multiplier = 10;

                VM.Width  = (maxPoint.X - minPoint.X) * multiplier + 2 * padding + 2;
                VM.Height = (maxPoint.Y - minPoint.Y) * multiplier + 2 * padding + 2;

                grid_MapOuter.Width  = VM.Width * 1.2;
                grid_MapOuter.Height = VM.Height * 1.2;

                grid_Map.Children.Clear();

                // Отрисовка линии
                void AddLine(Point p1, Point p2, Brush color, double thickness = 1)
                {
                    grid_Map.Children.Add(new Line
                    {
                        X1 = padding + multiplier * (p1.X - minPoint.X),
                        X2 = padding + multiplier * (p2.X - minPoint.X),
                        Y1 = padding + multiplier * (p1.Y - minPoint.Y),
                        Y2 = padding + multiplier * (p2.Y - minPoint.Y),
                        StrokeThickness = thickness,
                        Stroke          = color,
                    });
                }

                // Отрисовка дуги
                void AddArc(Point p1, Point p2, int direction)
                {
                    const double radius = 3;

                    var x1 = padding + multiplier * (p1.X - minPoint.X);
                    var x2 = padding + multiplier * (p2.X - minPoint.X);
                    var y1 = padding + multiplier * (p1.Y - minPoint.Y);
                    var y2 = padding + multiplier * (p2.Y - minPoint.Y);

                    var arc = new ArcSegment()
                    {
                        Point          = new WinPoint(x2, y2),
                        Size           = new Size(radius * multiplier, radius * multiplier),
                        SweepDirection = direction == 1 ? SweepDirection.Counterclockwise : SweepDirection.Clockwise,
                    };
                    var figure = new PathFigure()
                    {
                        StartPoint = new WinPoint(x1, y1)
                    };

                    figure.Segments.Add(arc);
                    var geometry = new PathGeometry();

                    geometry.Figures.Add(figure);
                    var path = new Path()
                    {
                        Data = geometry, Stroke = Brushes.Red, StrokeThickness = 1
                    };

                    grid_Map.Children.Add(path);
                }

                // Открисовка круга
                void AddEllipse(Point p1, Brush color, double diameter = 0.3)
                {
                    var x1 = padding + multiplier * (p1.X - minPoint.X);
                    var y1 = padding + multiplier * (p1.Y - minPoint.Y);

                    var size = diameter * multiplier;

                    grid_Map.Children.Add(new Ellipse()
                    {
                        Width  = size,
                        Height = size,
                        Fill   = color,
                        Margin = new Thickness(x1 - size / 2, y1 - size / 2, 0, 0),
                        HorizontalAlignment = HorizontalAlignment.Left,
                        VerticalAlignment   = VerticalAlignment.Top,
                    });
                }

                // Отрисовка треугольника
                void AddTriangle(Point p1, Brush fill, Brush border = null, double radius = 0.5)
                {
                    AddEllipse(p1, border);
                    var x1 = padding + multiplier * (p1.X - minPoint.X);
                    var y1 = padding + multiplier * (p1.Y - minPoint.Y);

                    var size = radius * multiplier;
                    var xc = size; var yc = size;

                    var triangle = new[]
                    {
                        new WinPoint(xc, yc + size),
                        new WinPoint(xc + size * 0.866, yc - size * 0.5),
                        new WinPoint(xc - size * 0.866, yc - size * 0.5),
                    };

                    var dxy     = Convert.ToInt32(p1.Degrees) % 90 == 45 ? size / 0.707 : size;
                    var polygon = new Polygon()
                    {
                        Width  = 2 * size,
                        Height = 2 * size,
                        Points = new PointCollection(triangle),
                        Stroke = border ?? fill,
                        Fill   = fill,
                    };
                    var polygonGrid = new Grid()
                    {
                        Width               = 2 * size,
                        Height              = 2 * size,
                        Margin              = new Thickness(x1 - dxy, y1 - dxy, 0, 0),
                        LayoutTransform     = new RotateTransform(p1.Degrees),
                        HorizontalAlignment = HorizontalAlignment.Left,
                        VerticalAlignment   = VerticalAlignment.Top,
                    };

                    polygonGrid.Children.Add(polygon);
                    grid_Map.Children.Add(polygonGrid);
                }

                // Сетка
                if (VM.ShouldDrawGrid)
                {
                    for (var i = (int)minPoint.X - 1; i <= Math.Ceiling(maxPoint.X) + 1; i++)
                    {
                        AddLine(new Point(i, minPoint.Y - 1), new Point(i, maxPoint.Y + 1), Brushes.DarkGray, 0.25);
                    }
                    for (var i = (int)minPoint.Y - 1; i <= Math.Ceiling(maxPoint.Y) + 1; i++)
                    {
                        AddLine(new Point(minPoint.X - 1, i), new Point(maxPoint.X + 1, i), Brushes.DarkGray, 0.25);
                    }
                }

                // Ось OY
                AddLine(new Point(0, 0), new Point(0, 1), Brushes.Black, 0.5);
                AddLine(new Point(0.2, 0.8), new Point(0, 1), Brushes.Black, 0.5);
                AddLine(new Point(-0.2, 0.8), new Point(0, 1), Brushes.Black, 0.5);

                // Трасса
                for (var i = 0; i < points.Length - 1 && i < MainVM.Model.Order.Count; i++)
                {
                    var block = MainVM.Model.Order[i];

                    if (block.StartsWith("T"))
                    {
                        // Рисуем дугу
                        var direction = MainVM.Model.Topology[i].Direction;
                        AddArc(points[i], points[i + 1], direction);
                    }
                    else
                    {
                        // Рисуем линию
                        AddLine(points[i], points[i + 1], Brushes.Red);

                        if (block.StartsWith("B"))
                        {
                            var rotatedPoint = MathFunctions.RotateCoordinates(points[i].Angle, points[i]);
                            rotatedPoint.Y += 1.5;
                            rotatedPoint.X += 0.2;
                            var p1 = MathFunctions.RotateCoordinates(-points[i].Angle, rotatedPoint);
                            rotatedPoint.Y += 1;
                            var p2 = MathFunctions.RotateCoordinates(-points[i].Angle, rotatedPoint);
                            rotatedPoint.X -= 0.2 * 2;
                            var p4 = MathFunctions.RotateCoordinates(-points[i].Angle, rotatedPoint);
                            rotatedPoint.Y -= 1;
                            var p3 = MathFunctions.RotateCoordinates(-points[i].Angle, rotatedPoint);

                            // Рисуем линии моста
                            AddLine(p1, p2, Brushes.Black, thickness: 0.5);
                            AddLine(p3, p4, Brushes.Black, thickness: 0.5);
                        }
                    }

                    // Рисуем точку стыка
                    AddEllipse(points[i], Brushes.Red, 0.2);
                }

                void AddText(string text, Point p, double fontSize = 7, Brush color = null)
                {
                    var x1 = padding + multiplier * (p.X - minPoint.X);
                    var y1 = padding + multiplier * (p.Y - minPoint.Y);

                    var textBox = new TextBlock()
                    {
                        Text                = text,
                        FontSize            = fontSize,
                        Foreground          = color ?? Brushes.Black,
                        LayoutTransform     = new ScaleTransform(1, -1),
                        Margin              = new Thickness(x1, y1, 0, 0),
                        HorizontalAlignment = HorizontalAlignment.Left,
                        VerticalAlignment   = VerticalAlignment.Top,
                    };

                    grid_Map.Children.Add(textBox);
                }

                // Точки маршрута

                foreach (var route in MainVM.Model.Points)
                {
                    AddEllipse(route, Brushes.Blue);

                    // Стоимость точек
                    AddText($"{route.Price:F0}", route);
                }

                // Второй курсор
                if (VM.Cursor2Point is Point cursorPoint2)
                {
                    var fill = cursorPoint2.Price > 0.5
                        ? new SolidColorBrush(Color.FromArgb(100, 100, 0, 255))
                        : Brushes.Transparent;

                    AddTriangle(cursorPoint2, fill, Brushes.BlueViolet);

                    AddText($"x:{cursorPoint2.X:F0} y:{cursorPoint2.Y:F0}\n", cursorPoint2, 5);
                }
                // Основной курсор алгоритма WASD
                if (VM.Cursor1Point is Point cursorPoint)
                {
                    var fill = cursorPoint.Price > 0.5
                        ? new SolidColorBrush(Color.FromArgb(100, 16, 255, 16))
                        : Brushes.Transparent;

                    AddTriangle(cursorPoint, fill, Brushes.Green);
                    AddText($"x:{cursorPoint.X:F0} y:{cursorPoint.Y:F0}\n", cursorPoint, 5);
                }

                // Центройды
                for (var i = 0; i < VM?.Context?.Centroids?.Count; i++)
                {
                    if (VM?.Context?.Centroids[i] is Point centroid)
                    {
                        AddEllipse(centroid, new SolidColorBrush(Colors.Aqua)
                        {
                            Opacity = 0.5
                        }, 0.75);

                        AddText($"{centroid.Price:F0}", new Point(centroid.X, centroid.Y - 1), 5, Brushes.DarkGray);
                    }
                }
            }
        }
示例#20
0
        private void ApplyStyle(Shape shape, bool fillShape)
        {
            if (_currentState.CurrentPen == null)
            {
                // Stock Pen
                var newBrush = new SolidColorBrush(Colors.Black);
            #if !NETFX_CORE
                newBrush.Freeze();
            #endif
                shape.Stroke = newBrush;
                shape.StrokeThickness = 1;
            }
            else
            {
                LogPen currentPen = _currentState.CurrentPen;

                if (currentPen.Width > 0)
                {
                    shape.StrokeThickness = ScaleWidth(currentPen.Width);
                }

                // Style
                if ((PenStyle)(currentPen.Style & 0x000F) == PenStyle.PS_NULL)
                {
                    // Do nothing, null is the default
                    //shape.Stroke = null;
                }
                else
                {
                    var newBrush = new SolidColorBrush(currentPen.Colour);
            #if !NETFX_CORE
                    newBrush.Freeze();
            #endif
                    shape.Stroke = newBrush;

                    if ((PenStyle)(currentPen.Style & 0x000F) == PenStyle.PS_DASH)
                    {
                        shape.StrokeDashArray.Add(30);
                        shape.StrokeDashArray.Add(10);
                    }
                    else if ((PenStyle)(currentPen.Style & 0x000F) == PenStyle.PS_DASHDOT)
                    {
                        shape.StrokeDashArray.Add(30);
                        shape.StrokeDashArray.Add(10);
                        shape.StrokeDashArray.Add(10);
                        shape.StrokeDashArray.Add(10);
                        shape.StrokeDashArray.Add(10);
                        shape.StrokeDashArray.Add(10);
                    }
                    else if ((PenStyle)(currentPen.Style & 0x000F) == PenStyle.PS_DASHDOTDOT)
                    {

                        shape.StrokeDashArray.Add(30);
                        shape.StrokeDashArray.Add(10);
                        shape.StrokeDashArray.Add(10);
                        shape.StrokeDashArray.Add(10);
                        shape.StrokeDashArray.Add(10);
                        shape.StrokeDashArray.Add(10);
                        shape.StrokeDashArray.Add(10);
                        shape.StrokeDashArray.Add(10);
                    }
                    else if ((PenStyle)(currentPen.Style & 0x000F) == PenStyle.PS_DOT)
                    {
                        shape.StrokeDashArray.Add(10);
                        shape.StrokeDashArray.Add(10);
                        shape.StrokeDashCap = PenLineCap.Round;
                    }
                }

                // Join
                if ((PenStyle)(currentPen.Style & 0xF000) == PenStyle.PS_JOIN_BEVEL)
                {
                    shape.StrokeLineJoin = PenLineJoin.Bevel;
                }
                else if ((PenStyle)(currentPen.Style & 0xF000) == PenStyle.PS_JOIN_MITER)
                {
                    // Do nothing, miter is the default
                    shape.StrokeLineJoin = PenLineJoin.Miter;

                    if (_miterLimit != 0)
                    {
                        shape.StrokeMiterLimit = _miterLimit;
                    }
                }
                else if ((PenStyle)(currentPen.Style & 0xF000) == PenStyle.PS_JOIN_ROUND)
                {
                    shape.StrokeLineJoin = PenLineJoin.Round;
                }

                // End cap
                if ((PenStyle)(currentPen.Style & 0x0F00) == PenStyle.PS_ENDCAP_FLAT)
                {
                    // Do nothing, flat is the default
                    // shape.StrokeEndLineCap = PenLineCap.Flat;
                    // shape.StrokeStartLineCap = PenLineCap.Flat;
                }
                else if ((PenStyle)(currentPen.Style & 0x0F00) == PenStyle.PS_ENDCAP_SQUARE)
                {
                    shape.StrokeEndLineCap = PenLineCap.Square;
                    shape.StrokeStartLineCap = PenLineCap.Square;
                }
                else if ((PenStyle)(currentPen.Style & 0x0F00) == PenStyle.PS_ENDCAP_ROUND)
                {
                    shape.StrokeEndLineCap = PenLineCap.Round;
                    shape.StrokeStartLineCap = PenLineCap.Round;
                }
            }

            if (_currentState.CurrentBrush == null & fillShape)
            {
                // Stock brush
                var newBrush = new SolidColorBrush(Colors.White);
            #if !NETFX_CORE
                newBrush.Freeze();
            #endif
                shape.Fill = newBrush;
            }
            else if (fillShape)
            {
                LogBrush currentBrush = _currentState.CurrentBrush;

                if (currentBrush.Style == BrushStyle.BS_NULL)
                {
                    // Do nothing, null is the default
                    // shape.Fill = null;
                }
                else if (currentBrush.Image != null)
                {
            #if !NETFX_CORE
                    var imgBrush = new ImageBrush
                                       {
                                           ImageSource = currentBrush.Image,
                                           Stretch = Stretch.None,
                                           TileMode = TileMode.Tile,
                                           Viewport =
                                               new Rect(0, 0, ScaleWidth(currentBrush.Image.Width),
                                                        ScaleHeight(currentBrush.Image.Height)),
                                           ViewportUnits = BrushMappingMode.Absolute,
                                           Viewbox =
                                               new Rect(0, 0, ScaleWidth(currentBrush.Image.Width),
                                                        ScaleHeight(currentBrush.Image.Height)),
                                           ViewboxUnits = BrushMappingMode.Absolute
                                       };

                    imgBrush.Freeze();

                    shape.Fill = imgBrush;
            #endif
                    // TODO: Figure out a way to stop the tile anti-aliasing
                }
                else if (currentBrush.Style == BrushStyle.BS_PATTERN
                    | currentBrush.Style == BrushStyle.BS_DIBPATTERN
                    | currentBrush.Style == BrushStyle.BS_DIBPATTERNPT)
                {
                    var newBrush = new SolidColorBrush(Colors.Black);
            #if !NETFX_CORE
                    newBrush.Freeze();
            #endif
                    shape.Fill = newBrush;
                }
                else if (currentBrush.Style == BrushStyle.BS_HATCHED)
                {
            #if !NETFX_CORE
                    var patternBrush = new VisualBrush();
                    var patternTile = new Canvas();
                    var stroke1 = new Path();
                    var stroke2 = new Path();
                    var figure1 = new PathFigure();
                    var figure2 = new PathFigure();
                    var segments1 = new PathSegmentCollection();
                    var segments2 = new PathSegmentCollection();

                    patternBrush.TileMode = TileMode.Tile;
                    patternBrush.Viewport = new Rect(0, 0, 10, 10);
                    patternBrush.ViewportUnits = BrushMappingMode.Absolute;
                    patternBrush.Viewbox = new Rect(0, 0, 10, 10);
                    patternBrush.ViewboxUnits = BrushMappingMode.Absolute;

                    stroke1.Data = new PathGeometry();
                    stroke2.Data = new PathGeometry();

                    switch (currentBrush.Hatch)
                    {
                        case HatchStyle.HS_BDIAGONAL:
                            // A 45-degree upward, left-to-right hatch.
                            figure1.StartPoint = new Point(0, 10);

                            var up45Segment = new LineSegment
                                {
                                    Point = new Point(10, 0)
                                };
                            segments1.Add(up45Segment);
                            figure1.Segments = segments1;

                            ((PathGeometry)stroke1.Data).Figures.Add(figure1);
                            patternTile.Children.Add(stroke1);
                            break;

                        case HatchStyle.HS_CROSS:
                            // A horizontal and vertical cross-hatch.
                            figure1.StartPoint = new Point(5, 0);
                            figure2.StartPoint = new Point(0, 5);

                            var downXSegment = new LineSegment
                                {
                                    Point = new Point(5, 10)
                                };
                            segments1.Add(downXSegment);
                            figure1.Segments = segments1;
                            var rightXSegment = new LineSegment
                                {
                                    Point = new Point(10, 5)
                                };
                            segments2.Add(rightXSegment);
                            figure1.Segments = segments1;
                            figure2.Segments = segments2;

                            ((PathGeometry)stroke1.Data).Figures.Add(figure1);
                            ((PathGeometry)stroke2.Data).Figures.Add(figure2);

                            patternTile.Children.Add(stroke1);
                            patternTile.Children.Add(stroke2);
                            break;

                        case HatchStyle.HS_DIAGCROSS:
                            // A 45-degree crosshatch.
                            figure1.StartPoint = new Point(0, 0);
                            figure2.StartPoint = new Point(0, 10);

                            var downDXSegment = new LineSegment
                                {
                                    Point = new Point(10, 10)
                                };
                            segments1.Add(downDXSegment);
                            figure1.Segments = segments1;
                            var rightDXSegment = new LineSegment
                                {
                                    Point = new Point(10, 0)
                                };
                            segments2.Add(rightDXSegment);
                            figure1.Segments = segments1;
                            figure2.Segments = segments2;

                            ((PathGeometry)stroke1.Data).Figures.Add(figure1);
                            ((PathGeometry)stroke2.Data).Figures.Add(figure2);

                            patternTile.Children.Add(stroke1);
                            patternTile.Children.Add(stroke2);
                            break;

                        case HatchStyle.HS_FDIAGONAL:
                            // A 45-degree downward, left-to-right hatch.
                            figure1.StartPoint = new Point(0, 0);

                            var down45Segment = new LineSegment
                                {
                                    Point = new Point(10, 10)
                                };
                            segments1.Add(down45Segment);
                            figure1.Segments = segments1;

                            ((PathGeometry)stroke1.Data).Figures.Add(figure1);
                            patternTile.Children.Add(stroke1);
                            break;

                        case HatchStyle.HS_HORIZONTAL:
                            // A horizontal hatch.
                            figure1.StartPoint = new Point(0, 10);

                            var bottomSegment = new LineSegment
                                {
                                    Point = new Point(10, 10)
                                };
                            segments1.Add(bottomSegment);
                            figure1.Segments = segments1;

                            ((PathGeometry)stroke1.Data).Figures.Add(figure1);
                            patternTile.Children.Add(stroke1);
                            break;

                        case HatchStyle.HS_VERTICAL:
                            // A vertical hatch.
                            figure1.StartPoint = new Point(10, 0);

                            var verticalSegment = new LineSegment
                                {
                                    Point = new Point(10, 10)
                                };
                            segments1.Add(verticalSegment);
                            figure1.Segments = segments1;

                            ((PathGeometry)stroke1.Data).Figures.Add(figure1);
                            patternTile.Children.Add(stroke1);
                            break;
                    }

                    patternBrush.Visual = patternTile;
                    //patternBrush.Freeze();  // Cant freeze a visual brush
                    shape.Fill = patternBrush;
            #endif
                }
                else
                {
                    var newBrush = new SolidColorBrush(currentBrush.Colour);
            #if !NETFX_CORE
                    newBrush.Freeze();
            #endif
                    shape.Fill = newBrush;
                }
            }
        }
示例#21
0
 public override void beginPath()
 {
     _path       = new PathGeometry();
     _pathFigure = null;
 }
示例#22
0
        public void Pie(Canvas surface, double left, double top, double right, double bottom, double radial1X, double radial1Y, double radial2X, double radial2Y)
        {
            var pie = new Path();
            var figure = new PathFigure();
            var segments = new PathSegmentCollection();

            var center = new Point(left + ((right - left) / 2), top + ((bottom - top) / 2));
            var degrees = Math.Atan2(radial1Y - center.Y, radial1X - center.X)
                            - Math.Atan2(radial2Y - center.Y, radial2X - center.X);

            degrees *= 57.2957795; // Convert from radians to degrees
            bool isLargeArc = Math.Abs(degrees) > 180;

            pie.Data = new PathGeometry();

            figure.IsClosed = true;
            figure.StartPoint = new Point(LtoDX(radial1X), LtoDY(radial1Y));
            var segment = new ArcSegment
                {
                    Point = new Point(LtoDX(radial1X),
                              LtoDY(radial1Y)),
                    Size = new Size((LtoDX(right) - LtoDX(left)) / 2,
                           (LtoDY(bottom) - LtoDY(top)) / 2),
                    RotationAngle = 0,
                    IsLargeArc = isLargeArc,
                    SweepDirection = SweepDirection.Counterclockwise,
                };

            segments.Add(segment);
            segments.Add(
                new LineSegment
                    {
                        Point = center
                    }
                );

            figure.Segments = segments;
            ((PathGeometry)pie.Data).Figures.Add(figure);

            ApplyStyle(pie, true);

            surface.Children.Add(pie);
        }
示例#23
0
        private static void OnValueChanged(DependencyObject d)
        {
            RadialGauge radialGauge = (RadialGauge)d;

            if (!double.IsNaN(radialGauge.Value))
            {
                if (radialGauge.StepSize != 0)
                {
                    radialGauge.Value = radialGauge.RoundToMultiple(radialGauge.Value, radialGauge.StepSize);
                }

                var middleOfScale = 100 - radialGauge.ScalePadding - (radialGauge.ScaleWidth / 2);
                var valueText     = radialGauge.GetTemplateChild(ValueTextPartName) as TextBlock;
                radialGauge.ValueAngle = radialGauge.ValueToAngle(radialGauge.Value);

                // Needle
                if (radialGauge._needle != null)
                {
                    radialGauge._needle.RotationAngleInDegrees = (float)radialGauge.ValueAngle;
                }

                // Trail
                var trail = radialGauge.GetTemplateChild(TrailPartName) as Path;
                if (trail != null)
                {
                    if (radialGauge.ValueAngle > radialGauge.NormalizedMinAngle)
                    {
                        trail.Visibility = Visibility.Visible;

                        if (radialGauge.ValueAngle - radialGauge.NormalizedMinAngle == 360)
                        {
                            // Draw full circle.
                            var eg = new EllipseGeometry();
                            eg.Center  = new Point(100, 100);
                            eg.RadiusX = 100 - radialGauge.ScalePadding - (radialGauge.ScaleWidth / 2);
                            eg.RadiusY = eg.RadiusX;
                            trail.Data = eg;
                        }
                        else
                        {
                            // Draw arc.
                            var pg = new PathGeometry();
                            var pf = new PathFigure();
                            pf.IsClosed   = false;
                            pf.StartPoint = radialGauge.ScalePoint(radialGauge.NormalizedMinAngle, middleOfScale);
                            var seg = new ArcSegment();
                            seg.SweepDirection = SweepDirection.Clockwise;
                            seg.IsLargeArc     = radialGauge.ValueAngle > (180 + radialGauge.NormalizedMinAngle);
                            seg.Size           = new Size(middleOfScale, middleOfScale);
                            seg.Point          = radialGauge.ScalePoint(Math.Min(radialGauge.ValueAngle, radialGauge.NormalizedMaxAngle), middleOfScale); // On overflow, stop trail at MaxAngle.
                            pf.Segments.Add(seg);
                            pg.Figures.Add(pf);
                            trail.Data = pg;
                        }
                    }
                    else
                    {
                        trail.Visibility = Visibility.Collapsed;
                    }
                }

                // Value Text
                if (valueText != null)
                {
                    valueText.Text = radialGauge.Value.ToString(radialGauge.ValueStringFormat);
                }
            }
        }
示例#24
0
        internal override void draw()
        {
            // 绘图形
            Path path  = new Path();
            Path patha = new Path();

            if (isFirstLayer)
            {
                //Data="M 100,100 A 200,200 45 0 0 0,0 A 200,200 45 0 1 90,100" />

                PathGeometry pg = new PathGeometry();
                PathFigure   pf = new PathFigure();
                pg.Figures.Add(pf);
                pf.StartPoint = from;

                PathGeometry pga = new PathGeometry();
                PathFigure   pfa = new PathFigure();
                pga.Figures.Add(pfa);
                pfa.StartPoint = froma;

                if (isUp)
                {
                    ArcSegment ps = new ArcSegment(to, new Size(len * 1.5, len * 1.5), 45, false, SweepDirection.Counterclockwise, false);
                    pf.Segments.Add(ps);
                    ps = new ArcSegment(from2, new Size(len * 1.5, len * 1.5), 45, false, SweepDirection.Clockwise, false);
                    pf.Segments.Add(ps);

                    ps = new ArcSegment(to, new Size(len * 1.5, len * 1.5), 45, false, SweepDirection.Counterclockwise, false);
                    pfa.Segments.Add(ps);
                    ps = new ArcSegment(froma2, new Size(len * 1.5, len * 1.5), 45, false, SweepDirection.Clockwise, false);
                    pfa.Segments.Add(ps);
                }
                else
                {
                    ArcSegment ps = new ArcSegment(to, new Size(len * 1.5, len * 1.5), 45, false, SweepDirection.Clockwise, false);
                    pf.Segments.Add(ps);
                    ps = new ArcSegment(from2, new Size(len * 1.5, len * 1.5), 45, false, SweepDirection.Counterclockwise, false);
                    pf.Segments.Add(ps);

                    ps = new ArcSegment(to, new Size(len * 1.5, len * 1.5), 45, false, SweepDirection.Clockwise, false);
                    pfa.Segments.Add(ps);
                    ps = new ArcSegment(froma2, new Size(len * 1.5, len * 1.5), 45, false, SweepDirection.Counterclockwise, false);
                    pfa.Segments.Add(ps);
                }

                path.Data            = pg;
                path.Fill            = branchBrush;
                path.StrokeThickness = 0;

                patha.Data = pga;
                byte gb = (byte)(255.0f * (1.0f - 1.0f * bones.Count(p => p.isWarning) / bones.Count));
                patha.Fill            = new SolidColorBrush(Color.FromRgb(255, gb, gb));
                patha.StrokeThickness = 0;
                patha.Effect          = new System.Windows.Media.Effects.BlurEffect()
                {
                    Radius = 5
                };
            }
            else
            {
                LineGeometry geo = new LineGeometry(from, to);
                path.Data             = geo;
                path.Stroke           = branchBrush;
                path.StrokeThickness  = thickness;
                path.StrokeEndLineCap = PenLineCap.Triangle;
            }
            if (isWarning)
            {
                path.Effect = new System.Windows.Media.Effects.DropShadowEffect()
                {
                    ShadowDepth = 0, BlurRadius = 5, Color = Colors.Yellow
                }
            }
            ;

            Canvas.SetZIndex(path, -1 * layer);
            fish.canv.Children.Add(path);

            Canvas.SetZIndex(patha, -1 * layer);
            fish.canv.Children.Add(patha);


            foreach (SubBone bon in bones)
            {
                bon.draw();
            }
        }
示例#25
0
 public DataPoint(DateTime Time, double Value, double X, double Y, FrameworkElement DataUIElement, PathFigure figure, LineSegment lineSegment, string Name = null, string Description = null)
 {
     this.Time           = Time;
     this.Value          = Value;
     this.X              = X;
     this.Y              = Y;
     this.DataUIElements = new List <FrameworkElement>();
     DataUIElements.Add(DataUIElement);
     this.Name        = Name;
     this.Description = Description;
     this.LineSegment = lineSegment;
     this.Figure      = figure;
 }
示例#26
0
        /// <summary>
        /// Adds a polygon to this path.
        /// </summary>
        public void AddPolygon(XPoint[] points)
        {
#if CORE
            int count = points.Length;
            if (count == 0)
                return;

            _corePath.MoveTo(points[0].X, points[0].Y);
            for (int idx = 0; idx < count - 1; idx++)
                _corePath.LineTo(points[idx].X, points[idx].Y, false);
            _corePath.LineTo(points[count - 1].X, points[count - 1].Y, true);
            _corePath.CloseSubpath();
#endif
#if GDI
            try
            {
                Lock.EnterGdiPlus();
                _gdipPath.AddPolygon(XGraphics.MakePointFArray(points));
            }
            finally { Lock.ExitGdiPlus(); }
#endif
#if WPF || NETFX_CORE
#if !SILVERLIGHT && !NETFX_CORE
            _pathGeometry.AddGeometry(GeometryHelper.CreatePolygonGeometry(XGraphics.MakePointArray(points), XFillMode.Alternate, true));
#else
            var figure = new PathFigure();
            figure.StartPoint = new SysPoint(points[0].X, points[0].Y);
            figure.IsClosed = true;

            PolyLineSegment segment = new PolyLineSegment();
            int count = points.Length;
            // For correct drawing the start point of the segment must not be the same as the first point.
            for (int idx = 1; idx < count; idx++)
                segment.Points.Add(new SysPoint(points[idx].X, points[idx].Y));
#if !SILVERLIGHT && !NETFX_CORE
            seg.IsStroked = true;
#endif
            figure.Segments.Add(segment);
            _pathGeometry.Figures.Add(figure);
#endif
            // TODO: NOT NEEDED
            //CloseFigure(); // StartFigure() isn't needed because AddGeometry() implicitly starts a new figure, but CloseFigure() is needed for the next adding not to continue this figure.
#endif
        }
示例#27
0
        public override void Draw(DrawingContext dc)
        {
            if (!IsVisible)
            {
                return;
            }
            base.Draw(dc);
            //
            //         p2
            //         /\
            //        /  \
            //     p4 -p3- p5
            //         |
            //         |
            //         p1
            //
            Vector v  = EndPoint - StartPoint;
            var    vn = v;

            vn.Normalize();
            if (v.Length > 0)
            {
                //
                // Startpoint that lies on the edge of an UmlDiagramClass
                //
                var p1 = StartConnectorPoint;
                //
                // Endpoint that lies on the edge of an UmlDiagramClass
                //
                var p2 = EndConnectorPoint;

                Vector endApproachVector = !DoubleUtility.AreClose(0.0, BendingOffset) ? GetDirectionVectorOnCurve(EndOffset) : vn;
                var    v1 = endApproachVector * Utils.Rotation30Matrix;
                var    v2 = endApproachVector * Utils.RotationMin30Matrix;

                v1.Normalize();
                v2.Normalize();

                var p3 = p2 - endApproachVector * Math.Cos(30 * Math.PI / 180) * ArrowLength;

                var p4 = p2 - v1 * ArrowLength;
                var p5 = p2 - v2 * ArrowLength;

                PathGeometry geo    = new PathGeometry();
                PathFigure   figure = new PathFigure();
                figure.StartPoint = StartPoint;
                if (!DoubleUtility.AreClose(0.0, BendingOffset))
                {
                    PolyQuadraticBezierSegment bezier = new PolyQuadraticBezierSegment();
                    bezier.Points.Add(BendingPoint);
                    bezier.Points.Add(EndPoint);
                    figure.Segments.Add(bezier);
                }
                else
                {
                    LineSegment lineSegment = new LineSegment(EndPoint, true);
                    figure.Segments.Add(lineSegment);
                }

                PathGeometry geo2        = new PathGeometry();
                PathFigure   arrowFigure = new PathFigure();
                arrowFigure.StartPoint = p2;
                PolyLineSegment polyLineSegment = new PolyLineSegment(new[] { p4, p5, p2 }, true);

                arrowFigure.Segments.Add(polyLineSegment);

                geo.Figures.Add(figure);
                geo2.Figures.Add(arrowFigure);
                dc.DrawGeometry(null, GetMainLinePen(), geo);
                dc.DrawGeometry(Utils.DefaultBackgroundBrush, Utils.DefaultPen, geo2);
            }
        }
        protected IEnumerable<Point> GetPoints(PathFigure figure)
        {
            yield return figure.StartPoint;

            foreach (PolyLineSegment segment in figure.Segments)
            {
                foreach (var point in segment.Points)
                {
                    yield return point;
                }
            }
        }
示例#29
0
        private IRenderingElement GenerateSgroupBrackets(Sgroup sgroup,
                                                         IList <SgroupBracket> brackets,
                                                         IReadOnlyDictionary <IAtom, AtomSymbol> symbols,
                                                         string subscriptSuffix,
                                                         string superscriptSuffix)
        {
            // brackets are square by default (style:0)
            var          style  = (int?)sgroup.GetValue(SgroupKey.CtabBracketStyle);
            bool         round  = style != null && style == 1;
            ElementGroup result = new ElementGroup();

            var atoms         = sgroup.Atoms;
            var crossingBonds = sgroup.Bonds;

            // easy to depict in correct orientation, we just
            // point each bracket at the atom of a crossing
            // bond that is 'in' the group - this scales
            // to more than two brackets

            // first we need to pair the brackets with the bonds
            var pairs = crossingBonds.Count == brackets.Count ? BracketBondPairs(brackets, crossingBonds) : Dictionaries.Empty <SgroupBracket, IBond>();

            // override bracket layout around single atoms to bring them in closer
            if (atoms.Count == 1)
            {
                IAtom atom = atoms.First();

                // e.g. 2 HCL, 8 H2O etc.
                if (IsUnsignedInt(subscriptSuffix) &&
                    !crossingBonds.Any() &&
                    symbols.ContainsKey(atom))
                {
                    TextOutline prefix       = new TextOutline('·' + subscriptSuffix, font, emSize).Resize(1 / scale, 1 / -scale);
                    Rect        prefixBounds = prefix.LogicalBounds;

                    AtomSymbol symbol = symbols[atom];

                    Rect bounds = symbol.GetConvexHull().Outline.Bounds;

                    // make slightly large
                    bounds = new Rect(bounds.Bottom - 2 * stroke,
                                      bounds.Left - 2 * stroke,
                                      bounds.Width + 4 * stroke,
                                      bounds.Height + 4 * stroke);

                    prefix = prefix.Translate(bounds.Bottom - prefixBounds.Top,
                                              symbol.GetAlignmentCenter().Y - prefixBounds.CenterY());

                    result.Add(GeneralPath.ShapeOf(prefix.GetOutline(), foreground));
                }
                // e.g. CC(O)nCC
                else if (crossingBonds.Count > 0)
                {
                    double scriptscale = labelScale;

                    TextOutline leftBracket  = new TextOutline("(", font, emSize).Resize(1 / scale, 1 / -scale);
                    TextOutline rightBracket = new TextOutline(")", font, emSize).Resize(1 / scale, 1 / -scale);

                    var leftCenter  = leftBracket.GetCenter();
                    var rightCenter = rightBracket.GetCenter();

                    if (symbols.ContainsKey(atom))
                    {
                        AtomSymbol symbol = symbols[atom];

                        var bounds = symbol.GetConvexHull().Outline.Bounds;
                        // make slightly large
                        bounds = new Rect(bounds.Left - 2 * stroke,
                                          bounds.Top - 2 * stroke,
                                          bounds.Width + 4 * stroke,
                                          bounds.Height + 4 * stroke);

                        leftBracket = leftBracket.Translate(bounds.Left - 0.1 - leftCenter.X,
                                                            symbol.GetAlignmentCenter().Y - leftCenter.Y);
                        rightBracket = rightBracket.Translate(bounds.Right + 0.1 - rightCenter.X,
                                                              symbol.GetAlignmentCenter().Y - rightCenter.Y);
                    }
                    else
                    {
                        Vector2 p = atoms.First().Point2D.Value;
                        leftBracket  = leftBracket.Translate(p.X - 0.2 - leftCenter.X, p.Y - leftCenter.Y);
                        rightBracket = rightBracket.Translate(p.X + 0.2 - rightCenter.X, p.Y - rightCenter.Y);
                    }

                    result.Add(GeneralPath.ShapeOf(leftBracket.GetOutline(), foreground));
                    result.Add(GeneralPath.ShapeOf(rightBracket.GetOutline(), foreground));

                    var rightBracketBounds = rightBracket.GetBounds();

                    // subscript/superscript suffix annotation
                    if (subscriptSuffix != null && subscriptSuffix.Any())
                    {
                        TextOutline subscriptOutline = LeftAlign(MakeText(subscriptSuffix.ToLowerInvariant(),
                                                                          new Vector2(rightBracketBounds.Right,
                                                                                      rightBracketBounds.Top - 0.1),
                                                                          new Vector2(-0.5 * rightBracketBounds.Width, 0),
                                                                          scriptscale));
                        result.Add(GeneralPath.ShapeOf(subscriptOutline.GetOutline(), foreground));
                    }
                    if (superscriptSuffix != null && superscriptSuffix.Any())
                    {
                        TextOutline superscriptOutline = LeftAlign(MakeText(superscriptSuffix.ToLowerInvariant(),
                                                                            new Vector2(rightBracketBounds.Right,
                                                                                        rightBracketBounds.Bottom + 0.1),
                                                                            new Vector2(-rightBracketBounds.Width, 0),
                                                                            scriptscale));
                        result.Add(GeneralPath.ShapeOf(superscriptOutline.GetOutline(), foreground));
                    }
                }
            }
            else if (pairs.Any())
            {
                SgroupBracket suffixBracket     = null;
                Vector2?      suffixBracketPerp = null;

                foreach (var e in pairs)
                {
                    var bracket     = e.Key;
                    var bond        = e.Value;
                    var inGroupAtom = atoms.Contains(bond.Begin) ? bond.Begin : bond.End;

                    var p1 = bracket.FirstPoint;
                    var p2 = bracket.SecondPoint;

                    var perp = VecmathUtil.NewPerpendicularVector(VecmathUtil.NewUnitVector(p1, p2));

                    // point the vector at the atom group
                    Vector2 midpoint = VecmathUtil.Midpoint(p1, p2);
                    if (Vector2.Dot(perp, VecmathUtil.NewUnitVector(midpoint, inGroupAtom.Point2D.Value)) < 0)
                    {
                        perp = Vector2.Negate(perp);
                    }
                    perp *= bracketDepth;

                    if (round)
                    {
                        result.Add(CreateRoundBracket(p1, p2, perp, midpoint));
                    }
                    else
                    {
                        result.Add(CreateSquareBracket(p1, p2, perp));
                    }

                    if (suffixBracket == null)
                    {
                        suffixBracket     = bracket;
                        suffixBracketPerp = perp;
                    }
                    else
                    {
                        // is this bracket better as a suffix?
                        Vector2 sp1      = suffixBracket.FirstPoint;
                        Vector2 sp2      = suffixBracket.SecondPoint;
                        double  bestMaxX = Math.Max(sp1.X, sp2.X);
                        double  thisMaxX = Math.Max(p1.X, p2.X);
                        double  bestMaxY = Math.Max(sp1.Y, sp2.Y);
                        double  thisMaxY = Math.Max(p1.Y, p2.Y);

                        // choose the most eastern or.. the most southern
                        double xDiff = thisMaxX - bestMaxX;
                        double yDiff = thisMaxY - bestMaxY;
                        if (xDiff > EQUIV_THRESHOLD || (xDiff > -EQUIV_THRESHOLD && yDiff < -EQUIV_THRESHOLD))
                        {
                            suffixBracket     = bracket;
                            suffixBracketPerp = perp;
                        }
                    }
                }

                // write the labels
                if (suffixBracket != null)
                {
                    Vector2 subSufPnt = suffixBracket.FirstPoint;
                    Vector2 supSufPnt = suffixBracket.SecondPoint;

                    // try to put the subscript on the bottom
                    double xDiff = subSufPnt.X - supSufPnt.X;
                    double yDiff = subSufPnt.Y - supSufPnt.Y;
                    if (yDiff > EQUIV_THRESHOLD || (yDiff > -EQUIV_THRESHOLD && xDiff > EQUIV_THRESHOLD))
                    {
                        Vector2 tmpP = subSufPnt;
                        subSufPnt = supSufPnt;
                        supSufPnt = tmpP;
                    }

                    // subscript/superscript suffix annotation
                    if (subscriptSuffix != null && subscriptSuffix.Any())
                    {
                        TextOutline subscriptOutline = LeftAlign(MakeText(subscriptSuffix.ToLowerInvariant(), subSufPnt, suffixBracketPerp.Value, labelScale));
                        result.Add(GeneralPath.ShapeOf(subscriptOutline.GetOutline(), foreground));
                    }
                    if (superscriptSuffix != null && superscriptSuffix.Any())
                    {
                        TextOutline superscriptOutline = LeftAlign(MakeText(superscriptSuffix.ToLowerInvariant(), supSufPnt, suffixBracketPerp.Value, labelScale));
                        result.Add(GeneralPath.ShapeOf(superscriptOutline.GetOutline(), foreground));
                    }
                }
            }
            else if (brackets.Count == 2)
            {
                var b1p1 = brackets[0].FirstPoint;
                var b1p2 = brackets[0].SecondPoint;
                var b2p1 = brackets[1].FirstPoint;
                var b2p2 = brackets[1].SecondPoint;

                var b1vec = VecmathUtil.NewUnitVector(b1p1, b1p2);
                var b2vec = VecmathUtil.NewUnitVector(b2p1, b2p2);

                var b1pvec = VecmathUtil.NewPerpendicularVector(b1vec);
                var b2pvec = VecmathUtil.NewPerpendicularVector(b2vec);

                // Point the vectors at each other
                if (Vector2.Dot(b1pvec, VecmathUtil.NewUnitVector(b1p1, b2p1)) < 0)
                {
                    b1pvec = Vector2.Negate(b1pvec);
                }
                if (Vector2.Dot(b2pvec, VecmathUtil.NewUnitVector(b2p1, b1p1)) < 0)
                {
                    b2pvec = Vector2.Negate(b2pvec);
                }

                // scale perpendicular vectors by how deep the brackets need to be
                b1pvec *= bracketDepth;
                b2pvec *= bracketDepth;

                // bad brackets
                if (double.IsNaN(b1pvec.X) || double.IsNaN(b1pvec.Y) ||
                    double.IsNaN(b2pvec.X) || double.IsNaN(b2pvec.Y))
                {
                    return(result);
                }

                {
                    var path = new PathGeometry();

                    if (round)
                    {
                        {
                            // bracket 1 (cp: control point)
                            var pf = new PathFigure
                            {
                                StartPoint = new Point(b1p1.X + b1pvec.X, b1p1.Y + b1pvec.Y)
                            };
                            Vector2 cpb1 = VecmathUtil.Midpoint(b1p1, b1p2);
                            cpb1 += VecmathUtil.Negate(b1pvec);
                            var seg = new QuadraticBezierSegment
                            {
                                Point1 = new Point(cpb1.X, cpb1.Y),
                                Point2 = new Point(b1p2.X + b1pvec.X, b1p2.Y + b1pvec.Y)
                            };
                            pf.Segments.Add(seg);
                            path.Figures.Add(pf);
                        }

                        {
                            // bracket 2 (cp: control point)
                            var pf = new PathFigure
                            {
                                StartPoint = new Point(b2p1.X + b2pvec.X, b2p1.Y + b2pvec.Y)
                            };
                            Vector2 cpb2 = VecmathUtil.Midpoint(b2p1, b2p2);
                            cpb2 += VecmathUtil.Negate(b2pvec);
                            var seg = new QuadraticBezierSegment
                            {
                                Point1 = new Point(cpb2.X, cpb2.Y),
                                Point2 = new Point(b2p2.X + b2pvec.X, b2p2.Y + b2pvec.Y)
                            };
                            pf.Segments.Add(seg);
                            path.Figures.Add(pf);
                        }
                    }
                    else
                    {
                        {
                            // bracket 1
                            var pf = new PathFigure
                            {
                                StartPoint = new Point(b1p1.X + b1pvec.X, b1p1.Y + b1pvec.Y)
                            };
                            var seg = new PolyLineSegment();
                            seg.Points.Add(new Point(b1p1.X, b1p1.Y));
                            seg.Points.Add(new Point(b1p2.X, b1p2.Y));
                            seg.Points.Add(new Point(b1p2.X + b1pvec.X, b1p2.Y + b1pvec.Y));
                            pf.Segments.Add(seg);
                            path.Figures.Add(pf);
                        }

                        {
                            // bracket 2
                            var pf = new PathFigure
                            {
                                StartPoint = new Point(b2p1.X + b2pvec.X, b2p1.Y + b2pvec.Y)
                            };
                            var seg = new PolyLineSegment();
                            seg.Points.Add(new Point(b2p1.X, b2p1.Y));
                            seg.Points.Add(new Point(b2p2.X, b2p2.Y));
                            seg.Points.Add(new Point(b2p2.X + b2pvec.X, b2p2.Y + b2pvec.Y));
                            pf.Segments.Add(seg);
                            path.Figures.Add(pf);
                        }
                    }

                    result.Add(GeneralPath.OutlineOf(path, stroke, foreground));
                }

                // work out where to put the suffix labels (e.g. ht/hh/eu) superscript
                // and (e.g. n, xl, c, mix) subscript
                // TODO: could be improved
                double b1MaxX = Math.Max(b1p1.X, b1p2.X);
                double b2MaxX = Math.Max(b2p1.X, b2p2.X);
                double b1MaxY = Math.Max(b1p1.Y, b1p2.Y);
                double b2MaxY = Math.Max(b2p1.Y, b2p2.Y);

                Vector2 subSufPnt = b2p2;
                Vector2 supSufPnt = b2p1;
                Vector2 subpvec   = b2pvec;

                double bXDiff = b1MaxX - b2MaxX;
                double bYDiff = b1MaxY - b2MaxY;

                if (bXDiff > EQUIV_THRESHOLD || (bXDiff > -EQUIV_THRESHOLD && bYDiff < -EQUIV_THRESHOLD))
                {
                    subSufPnt = b1p2;
                    supSufPnt = b1p1;
                    subpvec   = b1pvec;
                }

                double xDiff = subSufPnt.X - supSufPnt.X;
                double yDiff = subSufPnt.Y - supSufPnt.Y;

                if (yDiff > EQUIV_THRESHOLD || (yDiff > -EQUIV_THRESHOLD && xDiff > EQUIV_THRESHOLD))
                {
                    Vector2 tmpP = subSufPnt;
                    subSufPnt = supSufPnt;
                    supSufPnt = tmpP;
                }

                // subscript/superscript suffix annotation
                if (subscriptSuffix != null && subscriptSuffix.Any())
                {
                    TextOutline subscriptOutline = LeftAlign(MakeText(subscriptSuffix.ToLowerInvariant(), subSufPnt, subpvec, labelScale));
                    result.Add(GeneralPath.ShapeOf(subscriptOutline.GetOutline(), foreground));
                }
                if (superscriptSuffix != null && superscriptSuffix.Any())
                {
                    TextOutline superscriptOutline = LeftAlign(MakeText(superscriptSuffix.ToLowerInvariant(), supSufPnt, subpvec, labelScale));
                    result.Add(GeneralPath.ShapeOf(superscriptOutline.GetOutline(), foreground));
                }
            }
            return(result);
        }
示例#30
0
        void drawTail()
        {
            Path         path = new Path();
            PathGeometry pg   = new PathGeometry();

            path.Data = pg;

            Point           sp0, sp, cp1, cp2, ep;
            Vector          vc, vc2;
            double          zlen;
            RotateTransform r;
            PathFigure      pf = new PathFigure();

            pg.Figures.Add(pf);
            sp0           = new Point(to.X - 15, to.Y - fish.para.MainBoneThickness / 2);
            pf.StartPoint = sp0;
            //if (fish.para.fishDirection== EFishDirection.头向右)
            {
                ep   = new Point(20, 200);
                vc   = ep - sp0;
                zlen = vc.Length;
                vc.Normalize();
                r   = new RotateTransform(-90);
                vc2 = (Vector)r.Transform((Point)vc);
                cp1 = sp0 + 0.3 * zlen * vc;
                cp1 = cp1 + 0.1 * zlen * vc2;
                cp2 = sp0 + 0.7 * zlen * vc;
                cp2 = cp2 - 0.15 * zlen * vc2;
                BezierSegment bs = new BezierSegment(cp1, cp2, ep, true);
                pf.Segments.Add(bs);

                sp   = ep;
                ep   = new Point(20, fish.para.fishHeight - 200);
                vc   = ep - sp;
                zlen = vc.Length;
                vc.Normalize();
                r   = new RotateTransform(-90);
                vc2 = (Vector)r.Transform((Point)vc);
                cp1 = sp + 0.4 * zlen * vc;
                cp1 = cp1 + 0.3 * zlen * vc2;
                cp2 = sp + 0.6 * zlen * vc;
                cp2 = cp2 + 0.3 * zlen * vc2;
                bs  = new BezierSegment(cp1, cp2, ep, true);
                pf.Segments.Add(bs);

                sp   = ep;
                ep   = new Point(to.X - 15, to.Y + fish.para.MainBoneThickness / 2);
                vc   = ep - sp;
                zlen = vc.Length;
                vc.Normalize();
                r   = new RotateTransform(-90);
                vc2 = (Vector)r.Transform((Point)vc);
                cp1 = sp + 0.3 * zlen * vc;
                cp1 = cp1 - 0.13 * zlen * vc2;
                cp2 = sp + 0.7 * zlen * vc;
                cp2 = cp2 + 0.13 * zlen * vc2;
                bs  = new BezierSegment(cp1, cp2, ep, true);
                pf.Segments.Add(bs);
                pf.Segments.Add(new LineSegment(sp0, true));

                path.Stroke          = Brushes.Silver;
                path.StrokeThickness = 1;
                path.Fill            = fish.para.HeadTailBrush;
                path.Opacity         = fish.para.HeadTailOpacity;

                fish.canv.Children.Add(path);
            }
        }
示例#31
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="arc"></param>
        /// <param name="dx"></param>
        /// <param name="dy"></param>
        /// <param name="db"></param>
        /// <param name="r"></param>
        public void Draw(object dc, XArc arc, double dx, double dy, ImmutableArray <ShapeProperty> db, Record r)
        {
            var _dc = dc as DrawingContext;

            var style = arc.Style;

            if (style == null)
            {
                return;
            }

            double thickness = style.Thickness / _state.Zoom;
            double half      = thickness / 2.0;

            Tuple <Brush, Pen> cache = null;
            Brush fill;
            Pen   stroke;

            if (_enableStyleCache &&
                _styleCache.TryGetValue(style, out cache))
            {
                fill   = cache.Item1;
                stroke = cache.Item2;
            }
            else
            {
                fill   = CreateBrush(style.Fill);
                stroke = CreatePen(style, thickness);
                if (_enableStyleCache)
                {
                    _styleCache.Add(style, Tuple.Create(fill, stroke));
                }
            }

            var a = WpfArc.FromXArc(arc, dx, dy);

            PathGeometry pg = null;

            if (_enableArcCache &&
                _arcCache.TryGetValue(arc, out pg))
            {
                var pf = pg.Figures[0];
                pf.StartPoint = new Point(a.Start.X, a.Start.Y);
                pf.IsFilled   = arc.IsFilled;
                var segment = pf.Segments[0] as ArcSegment;
                segment.Point      = new Point(a.End.X, a.End.Y);
                segment.Size       = new Size(a.Radius.Width, a.Radius.Height);
                segment.IsLargeArc = a.IsLargeArc;
                segment.IsStroked  = arc.IsStroked;
            }
            else
            {
                var pf = new PathFigure()
                {
                    StartPoint = new Point(a.Start.X, a.Start.Y),
                    IsFilled   = arc.IsFilled
                };

                var segment = new ArcSegment(
                    new Point(a.End.X, a.End.Y),
                    new Size(a.Radius.Width, a.Radius.Height),
                    0.0,
                    a.IsLargeArc, SweepDirection.Clockwise,
                    arc.IsStroked);

                //segment.Freeze();
                pf.Segments.Add(segment);
                //pf.Freeze();
                pg = new PathGeometry();
                pg.Figures.Add(pf);
                //pg.Freeze();

                if (_enableArcCache)
                {
                    _arcCache.Add(arc, pg);
                }
            }

            DrawPathGeometryInternal(_dc, half, fill, stroke, arc.IsStroked, arc.IsFilled, pg);
        }
	// Reset this path.
	public void Reset()
			{
				pathPoints = new PointF[0]; // reset path points
				actualFigure = null;
				pathFigures.Clear();
				needPenBrush = false;
				fillMode = FillMode.Alternate;
			}
示例#33
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="dc"></param>
        /// <param name="bezier"></param>
        /// <param name="dx"></param>
        /// <param name="dy"></param>
        /// <param name="db"></param>
        /// <param name="r"></param>
        public void Draw(object dc, XBezier bezier, double dx, double dy, ImmutableArray <ShapeProperty> db, Record r)
        {
            var _dc = dc as DrawingContext;

            var style = bezier.Style;

            if (style == null)
            {
                return;
            }

            double thickness = style.Thickness / _state.Zoom;
            double half      = thickness / 2.0;

            Tuple <Brush, Pen> cache = null;
            Brush fill;
            Pen   stroke;

            if (_enableStyleCache &&
                _styleCache.TryGetValue(style, out cache))
            {
                fill   = cache.Item1;
                stroke = cache.Item2;
            }
            else
            {
                fill   = CreateBrush(style.Fill);
                stroke = CreatePen(style, thickness);
                if (_enableStyleCache)
                {
                    _styleCache.Add(style, Tuple.Create(fill, stroke));
                }
            }

            PathGeometry pg = null;

            if (_enableBezierCache &&
                _bezierCache.TryGetValue(bezier, out pg))
            {
                var pf = pg.Figures[0];
                pf.StartPoint = new Point(bezier.Point1.X + dx, bezier.Point1.Y + dy);
                pf.IsFilled   = bezier.IsFilled;
                var bs = pf.Segments[0] as BezierSegment;
                bs.Point1    = new Point(bezier.Point2.X + dx, bezier.Point2.Y + dy);
                bs.Point2    = new Point(bezier.Point3.X + dx, bezier.Point3.Y + dy);
                bs.Point3    = new Point(bezier.Point4.X + dx, bezier.Point4.Y + dy);
                bs.IsStroked = bezier.IsStroked;
            }
            else
            {
                var pf = new PathFigure()
                {
                    StartPoint = new Point(bezier.Point1.X + dx, bezier.Point1.Y + dy),
                    IsFilled   = bezier.IsFilled
                };
                var bs = new BezierSegment(
                    new Point(bezier.Point2.X + dx, bezier.Point2.Y + dy),
                    new Point(bezier.Point3.X + dx, bezier.Point3.Y + dy),
                    new Point(bezier.Point4.X + dx, bezier.Point4.Y + dy),
                    bezier.IsStroked);
                //bs.Freeze();
                pf.Segments.Add(bs);
                //pf.Freeze();
                pg = new PathGeometry();
                pg.Figures.Add(pf);
                //pg.Freeze();

                if (_enableBezierCache)
                {
                    _bezierCache.Add(bezier, pg);
                }
            }

            DrawPathGeometryInternal(_dc, half, fill, stroke, bezier.IsStroked, bezier.IsFilled, pg);
        }
		public object Clone() {
			PathFigure cpy = new PathFigure();
			foreach( PathObject o in pathObjs ) {
				cpy.AddPathObject( o.Clone() );
			}
			return cpy;
		}
示例#35
0
        /// <summary>
        /// Draws the pie piece
        /// </summary>
        private void SetRenderData()
        {
            var innerArcStartPoint = PieUtils.ComputeCartesianCoordinate(RotationAngle, InnerRadius, this);

            innerArcStartPoint.X += XOffset;
            innerArcStartPoint.Y += YOffset;
            var innerArcEndPoint = PieUtils.ComputeCartesianCoordinate(RotationAngle + WedgeAngle, InnerRadius, this);

            innerArcEndPoint.X += XOffset;
            innerArcEndPoint.Y += YOffset;
            var outerArcStartPoint = PieUtils.ComputeCartesianCoordinate(RotationAngle, Radius, this);

            outerArcStartPoint.X += XOffset;
            outerArcStartPoint.Y += YOffset;
            var outerArcEndPoint = PieUtils.ComputeCartesianCoordinate(RotationAngle + WedgeAngle, Radius, this);

            outerArcEndPoint.X += XOffset;
            outerArcEndPoint.Y += YOffset;
            var innerArcMidPoint = PieUtils.ComputeCartesianCoordinate(RotationAngle + WedgeAngle * .5, InnerRadius, this);

            innerArcMidPoint.X += XOffset;
            innerArcMidPoint.Y += YOffset;
            var outerArcMidPoint = PieUtils.ComputeCartesianCoordinate(RotationAngle + WedgeAngle * .5, Radius, this);

            outerArcMidPoint.X += XOffset;
            outerArcMidPoint.Y += YOffset;

            var largeArc         = WedgeAngle > 180.0d;
            var requiresMidPoint = Math.Abs(WedgeAngle - 360) < .01;

            if (PushOut > 0 && !requiresMidPoint)
            {
                var offset = PieUtils.ComputeCartesianCoordinate(RotationAngle + WedgeAngle / 2, PushOut, this);
                offset.X             -= Width * .5;
                offset.Y             -= Height * .5;
                innerArcStartPoint.X += offset.X;
                innerArcStartPoint.Y += offset.Y;
                innerArcEndPoint.X   += offset.X;
                innerArcEndPoint.Y   += offset.Y;
                outerArcStartPoint.X += offset.X;
                outerArcStartPoint.Y += offset.Y;
                outerArcEndPoint.X   += offset.X;
                outerArcEndPoint.Y   += offset.Y;
            }

            var outerArcSize = new Size(Radius, Radius);
            var innerArcSize = new Size(InnerRadius, InnerRadius);

            var pathFigure = new PathFigure {
                IsClosed = true, IsFilled = true, StartPoint = innerArcStartPoint
            };

            if (requiresMidPoint)
            {
                pathFigure.Segments.Add(new LineSegment {
                    Point = outerArcStartPoint
                });
                pathFigure.Segments.Add(new ArcSegment {
                    Point = outerArcMidPoint, Size = outerArcSize, RotationAngle = 0, IsLargeArc = false, SweepDirection = SweepDirection.Clockwise
                });
                pathFigure.Segments.Add(new ArcSegment {
                    Point = outerArcEndPoint, Size = outerArcSize, RotationAngle = 0, IsLargeArc = false, SweepDirection = SweepDirection.Clockwise
                });
                pathFigure.Segments.Add(new LineSegment {
                    Point = innerArcEndPoint
                });
                pathFigure.Segments.Add(new ArcSegment {
                    Point = innerArcMidPoint, Size = innerArcSize, RotationAngle = 0, IsLargeArc = false, SweepDirection = SweepDirection.Counterclockwise
                });
                pathFigure.Segments.Add(new ArcSegment {
                    Point = innerArcStartPoint, Size = innerArcSize, RotationAngle = 0, IsLargeArc = false, SweepDirection = SweepDirection.Counterclockwise
                });
            }
            else
            {
                pathFigure.Segments.Add(new LineSegment {
                    Point = outerArcStartPoint
                });
                pathFigure.Segments.Add(new ArcSegment {
                    Point = outerArcEndPoint, Size = outerArcSize, RotationAngle = 0, IsLargeArc = largeArc, SweepDirection = SweepDirection.Clockwise
                });
                pathFigure.Segments.Add(new LineSegment {
                    Point = innerArcEndPoint
                });
                pathFigure.Segments.Add(new ArcSegment {
                    Point = innerArcStartPoint, Size = innerArcSize, RotationAngle = 0, IsLargeArc = largeArc, SweepDirection = SweepDirection.Counterclockwise
                });
            }

            Data = new PathGeometry {
                Figures = new PathFigureCollection()
                {
                    pathFigure
                }, FillRule = FillRule.EvenOdd
            };
        }
示例#36
0
        public MainWindow()
        {
            // This should only be done once,
            // so it is being done here.
            //             Processing.Audio.Initialize();
            InitializeComponent();

            MainWindow.height = (int)this.Height;
            MainWindow.width = (int)this.Width;

            DispatcherTimer Timer = new DispatcherTimer();
            Timer.Interval = TimeSpan.FromMilliseconds(tickAmount);

            Path path = new Path();
            path.Stroke = System.Windows.Media.Brushes.RoyalBlue;
            path.StrokeThickness = 10;
            mainCanvas.Children.Add(path);

            Timer.Tick += (delegate(object s, EventArgs args)
            {
                if (!_isManipulating)
                {
                    if (currentlySelectedObject != null )
                    {
                        if (angle > 360)
                        {
                            if (currentlySelectedObject is Button)
                            {
                                ((Button)currentlySelectedObject).PerformClick();
                            }
                            else if (currentlySelectedObject is NavigationButton)
                            {
                                ((NavigationButton)currentlySelectedObject).Click();
                            }
                            else
                            {
                                ((SelectionPage)currentPage).Click();
                            }
                            path.Visibility = Visibility.Hidden;
                            angle = 0;
                        }
                        else
                        {
                            path.Visibility = Visibility.Visible;
                            System.Windows.Point mousePos = Mouse.GetPosition(mainCanvas);
                            System.Windows.Point endPoint = new System.Windows.Point(mousePos.X + 40 * Math.Sin(angle / 180.0 * Math.PI), mousePos.Y - 40 * Math.Cos(angle / 180.0 * Math.PI));

                            PathFigure figure = new PathFigure();
                            figure.StartPoint = new System.Windows.Point(mousePos.X, mousePos.Y - 40);

                            figure.Segments.Add(new ArcSegment(
                                endPoint,
                                new System.Windows.Size(40, 40),
                                0,
                                angle >= 180,
                                SweepDirection.Clockwise,
                                true
                            ));

                            PathGeometry geometry = new PathGeometry();
                            geometry.Figures.Add(figure);

                            path.Data = geometry;
                            // Number of ticks in one second --> number of degrees
                            angle += (360 / (1000 / tickAmount)); // <<<< CHANGE THIS BACK!!
                        }
                    }
                    else
                    {
                        path.Visibility = Visibility.Hidden;
                        angle = 0;
                    }
                }
            });

            homePage = new HomePage();
            browseMusicPage = new BrowseMusic();
            browseTutorialsPage = new BrowseTutorials();
            freeFormPage = new FreeFormMode();
            // tutorPage = new TutorMode();
            soloPage = new SoloPage();
            loadingPage = new LoadingPage();

            frame.Navigate(homePage);
            currentPage = homePage;
            Timer.Start();
            AddHandler(Keyboard.KeyDownEvent, (KeyEventHandler)HandleKeyDownEvent);
            AddHandler(Keyboard.KeyUpEvent, (KeyEventHandler)HandleKeyUpEvent);

            // Set the cursor to a hand image
            this.Cursor = new Cursor(new System.IO.MemoryStream(Properties.Resources.hand));
        }
示例#37
0
        internal static void TranslateSelection(PathEditorTarget pathEditorTarget, ICollection <PathPart> pathParts, Vector offset)
        {
            List <BitArray> list = new List <BitArray>(pathEditorTarget.PathGeometry.Figures.Count);

            for (int index = 0; index < pathEditorTarget.PathGeometry.Figures.Count; ++index)
            {
                list.Add(new BitArray(PathFigureUtilities.PointCount(pathEditorTarget.PathGeometry.Figures[index]), false));
            }
            foreach (PathPart pathPart in (IEnumerable <PathPart>)pathParts)
            {
                PathPoint pathPoint = pathPart as PathPoint;
                if ((PathPart)pathPoint != (PathPart)null)
                {
                    if (pathPoint.PartIndex < list[pathPoint.FigureIndex].Count)
                    {
                        list[pathPoint.FigureIndex][pathPoint.PartIndex] = true;
                    }
                }
                else
                {
                    PathSegment pathSegment = pathPart as PathSegment;
                    if ((PathPart)pathSegment != (PathPart)null)
                    {
                        list[pathSegment.FigureIndex][pathSegment.PartIndex] = true;
                        PathFigure pathFigure = pathEditorTarget.PathGeometry.Figures[pathPart.FigureIndex];
                        if (pathFigure.IsClosed && pathPart.PartIndex == 0)
                        {
                            int num1 = PathFigureUtilities.PointCount(pathFigure);
                            int num2 = 1;
                            if (PathFigureUtilities.IsCloseSegmentDegenerate(pathFigure))
                            {
                                num2 = PathSegmentUtilities.GetPointCount(pathFigure.Segments[pathFigure.Segments.Count - 1]);
                            }
                            list[pathSegment.FigureIndex][num1 - num2] = true;
                        }
                        else
                        {
                            int segmentIndex;
                            int segmentPointIndex;
                            PathFigureUtilities.GetSegmentFromPointIndex(pathFigure, pathPart.PartIndex, out segmentIndex, out segmentPointIndex);
                            int pointCount = PathSegmentUtilities.GetPointCount(pathFigure.Segments[segmentIndex]);
                            int index      = pathSegment.PartIndex - pointCount;
                            if (index >= 0)
                            {
                                list[pathSegment.FigureIndex][index] = true;
                            }
                        }
                    }
                }
            }
            for (int figureIndex = 0; figureIndex < pathEditorTarget.PathGeometry.Figures.Count; ++figureIndex)
            {
                BitArray         bitArray         = list[figureIndex];
                PathFigureEditor pathFigureEditor = new PathFigureEditor(pathEditorTarget.PathGeometry.Figures[figureIndex], pathEditorTarget.PathDiffChangeList, figureIndex);
                int num = PathFigureUtilities.PointCount(pathFigureEditor.PathFigure);
                for (int index = 0; index < num; ++index)
                {
                    if (bitArray[index])
                    {
                        pathFigureEditor.MovePoint(index, offset + pathFigureEditor.GetPoint(index));
                    }
                }
            }
        }
示例#38
0
        public void LineTo(Canvas surface, double x, double y)
        {
            var line = new Path();
            var curPos = _currentState.CurrentPosition;
            var startPos = new Point(LtoDX(curPos.X), LtoDY(curPos.Y));
            var endPos = new Point(LtoDX(x), LtoDY(y));

            #if NETFX_CORE
            var geometry = new PathGeometry();
            var figure = new PathFigure();

            geometry.Figures.Add(figure);
            figure.StartPoint = startPos;
            figure.Segments.Add(
                new LineSegment()
                {
                    Point = endPos
                }
            );
            #else
            var geometry = new StreamGeometry();

            using (var ctx = geometry.Open())
            {
                ctx.BeginFigure(startPos, false, false);
                ctx.LineTo(endPos, true, false);
            }

            geometry.Freeze();
            #endif

            line.Data = geometry;
            #if !NETFX_CORE
            line.SnapsToDevicePixels = true;
            #endif

            ApplyStyle(line, false);

            surface.Children.Add(line);

            _currentState.CurrentPosition = new Point(x, y);
        }
示例#39
0
        /// <summary>
        /// This method is called by the framework to create a <see cref="FrameworkElement"/>
        /// that will be included into the <see cref="IRenderContext"/>.
        /// </summary>
        /// <param name="context">The context that describes where the visual will be used.</param>
        /// <returns>
        /// The arrow visual to include in the canvas object visual tree./>.
        /// </returns>
        /// <seealso cref="UpdateVisual"/>
        Visual IVisualCreator.CreateVisual(IRenderContext context)
        {
            // Create a new Path to draw the arrow
            if (arrowFigure == null)
            {
                arrowFigure = new PathFigure
                {
                    StartPoint = new Point(-7, -thickness / 2),
                    Segments   =
                    {
                        new LineSegment {
                            Point = new Point(-7, thickness / 2)
                        },
                        new BezierSegment
                        {
                            Point1 = new Point(-5, thickness / 2),
                            Point2 = new Point(-1.5, thickness / 2),
                            Point3 = new Point(1, thickness * 1.666)
                        },
                        new BezierSegment
                        {
                            Point1 = new Point(0, thickness * 0.833),
                            Point2 = new Point(0, -thickness * 0.833),
                            Point3 = new Point(1, -thickness * 1.666)
                        },
                        new BezierSegment
                        {
                            Point1 = new Point(-1.5, -thickness / 2),
                            Point2 = new Point(-5, -thickness / 2),
                            Point3 = new Point(-7, -thickness / 2)
                        }
                    }
                };
                arrowFigure.Freeze();
            }

            Path p = new Path
            {
                // set Stretch, MinWidth and MinHeight so Path gets drawn in negative coordinate range
                Stretch   = Stretch.None,
                MinWidth  = 1,
                MinHeight = 1,
                Fill      = pathFill,
                // Draw arrow outline
                Data = new PathGeometry
                {
                    Figures = { arrowFigure }
                }
            };

            // Remember thickness for update
            p.SetRenderDataCache(thickness);

            // Rotate arrow and move it to correct position
            p.RenderTransform = new MatrixTransform
            {
                Matrix =
                    new Matrix(direction.X, direction.Y, -direction.Y, direction.X, anchor.X, anchor.Y)
            };
            return(p);
        }
示例#40
0
        //public static Line CreateLine(GBoxObj parent, GBoxObj child)
        //{
        //    Line l = new Line();
        //    l.X1 = parent.ColorBox.X + parent.ColorBox.Width / 2;
        //    l.Y1 = parent.ColorBox.Y + parent.ColorBox.Height;
        //    l.X2 = child.ColorBox.X + child.ColorBox.Width / 2;
        //    l.Y2 = child.ColorBox.Y;
        //    l.Tag = parent.Tag.ToString() + StaticCfg.Ins.ParentChildSplit + child.Tag.ToString();
        //    if (Math.Min(parent.GTagBox.Level, child.GTagBox.Level) == 0)
        //    {
        //        l.Stroke = new SolidColorBrush(GetColor(parent.GTagBox.Distance + 1, parent.GTagBox.Level + 1));
        //        l.StrokeThickness = StaticCfg.Ins.StrokeThickness * 1.5;
        //        l.StrokeDashArray = StaticCfg.Ins.StrokeDashArray;
        //    }
        //    else
        //    {
        //        l.Stroke = new SolidColorBrush(GetColor(parent.GTagBox.Distance + 1, parent.GTagBox.Level + 1));
        //        l.StrokeThickness = StaticCfg.Ins.StrokeThickness;
        //        l.StrokeDashArray = StaticCfg.Ins.StrokeDashArray;
        //    }
        //    return l;
        //}
        public static Path CreateBezier(Tuple <GTagBoxTree, GTagBoxTree, int> p_c, TreeLayoutEnv env)
        {
            GTagBoxTree p      = p_c.Item1;
            GTagBoxTree c      = p_c.Item2;
            int         direct = (int)p_c.Item3;

            System.Windows.Point p1 = new System.Windows.Point();
            System.Windows.Point p5 = new System.Windows.Point();
            System.Windows.Point p2 = new System.Windows.Point();
            System.Windows.Point p4 = new System.Windows.Point();
            System.Windows.Point p3 = new System.Windows.Point();

            if (direct == 1)
            {
                p1.X = p.GTagBox.InnerBox.Right;
                p5.X = c.GTagBox.InnerBox.Left;
            }
            else
            {
                p1.X = p.GTagBox.InnerBox.Left;
                p5.X = c.GTagBox.InnerBox.Right;
            }
            p1.Y = (p.GTagBox.InnerBox.Top + p.GTagBox.InnerBox.Bottom) / 2;
            p5.Y = (c.GTagBox.InnerBox.Top + c.GTagBox.InnerBox.Bottom) / 2;


            p3.X = (p1.X + p5.X) / 2;
            p3.Y = (p1.Y + p5.Y) / 2;

            const int N = 3;

            p2.X = (p1.X * N + p5.X) / (N + 1);
            p4.X = (p1.X + p5.X * N) / (N + 1);

            p2.Y = p1.Y;
            p4.Y = p5.Y;



            Path path = env.New(p_c);


            if (path.Data == null)
            {
                PathGeometry         pg   = new PathGeometry();
                PathFigureCollection pfc  = new PathFigureCollection();
                PathFigure           pf   = new PathFigure();
                BezierSegment        seg1 = new BezierSegment(p1, p2, p3, true);
                seg1.IsSmoothJoin = true;
                BezierSegment seg2 = new BezierSegment(p3, p4, p5, true);
                seg2.IsSmoothJoin = true;

                //Path->PathGeometry->PathFigureCollection->PathFigure->PathSegmentCollection->BezierSegment
                path.Data = pg;
                //PathGeometry
                pg.Figures = pfc;
                //PathFigureCollection
                pfc.Add(pf);

                //PF
                pf.StartPoint = p1;
                pf.Segments.Add(seg1);
                pf.Segments.Add(seg2);
                pg.Figures.Add(pf);
            }
            else
            {
                PathGeometry         pg  = path.Data as PathGeometry;
                PathFigureCollection pfc = pg.Figures as PathFigureCollection;
                PathFigure           pf  = pfc[0] as PathFigure;
                pf.StartPoint = p1;
                BezierSegment seg1 = pf.Segments[0] as BezierSegment;
                BezierSegment seg2 = pf.Segments[1] as BezierSegment;
                seg1.Point1 = p1; seg1.Point2 = p2; seg1.Point3 = p3;
                seg2.Point1 = p3; seg2.Point2 = p4; seg2.Point3 = p5;
                //pg.Figures.Add(pf);
            }
            SetBezierStyle(p.GTagBox, c.GTagBox, path);
            return(path);
        }
示例#41
0
        private void RenderColorChart(DrawingContext dc, double width, double height)
        {
            //Determine the radius of the overall circle; we want this to be square in order to get a true circle, so use the min. extent
            double dblRadius = Math.Min(width / 2, height / 2);
            var    szRadius  = new Size(dblRadius, dblRadius);

            //Calculate the center of the control
            var ptCenter = new Point(dblRadius, dblRadius);


            if (SectorBrushes != null && SectorBrushes.Count > 1)
            {
                //The radius (degrees) that a single sector will cover
                double dblSectorRadius = 360d / SectorBrushes.Count;

                for (int intSectorCounter = 0; intSectorCounter < SectorBrushes.Count; intSectorCounter++)
                {
                    //Get the start- and end-points of the current arc segment to be drawn
                    var ptArcStartPoint = GetPointAtAngle(ptCenter, dblRadius, intSectorCounter * dblSectorRadius);
                    var ptArcEndPoint   = GetPointAtAngle(ptCenter, dblRadius, (intSectorCounter + 1) * dblSectorRadius);

                    //The bounding rectangle of the current arc Sector
                    var rctArcRect = new Rect(ptArcStartPoint, ptArcEndPoint);

                    //Construct the shape
                    var pg = new PathGeometry();
                    var pf = new PathFigure();
                    pg.Figures.Add(pf);
                    pf.StartPoint = ptArcStartPoint;
                    pf.IsFilled   = true;

                    // Add the current sector's arc-segment
                    pf.Segments.Add(
                        new ArcSegment(
                            ptArcEndPoint,
                            szRadius,
                            dblSectorRadius,
                            (dblSectorRadius >= 180),
                            SweepDirection.Clockwise,
                            false
                            )
                        );

                    // Add a line that ends in the center of the control
                    pf.Segments.Add(
                        new LineSegment(ptCenter, true)
                        );

                    // Close the figure (IOW, this will add a line between the center of the control and
                    // the arc's start point, resulting in a pie shape)
                    pf.IsClosed = true;

                    //Draw the arc (skipping the Pen used for drawing a line around the shape)
                    dc.DrawGeometry(SectorBrushes[intSectorCounter], null, pg);
                }
            }
            else if (SectorBrushes != null && SectorBrushes.Count == 1)
            {
                dc.DrawEllipse(SectorBrushes[0], null, ptCenter, dblRadius, dblRadius);
            }

            //Draw a circle around the sectors, if both a non-transparent color and a StrokeWidth>0 have been supplied.
            if (StrokeColor != null && StrokeColor != Colors.Transparent && StrokeWidth > 0)
            {
                dc.DrawEllipse(null, CachedStrokePen, ptCenter, dblRadius, dblRadius);
            }
        }
示例#42
0
        private void UpdatePath()
        {
            var innerRadius = InnerRadius + StrokeThickness / 2;
            var outerRadius = Radius - StrokeThickness / 2;

            if (_isUpdating ||
                ActualWidth == 0 ||
                innerRadius <= 0 ||
                outerRadius < innerRadius)
            {
                return;
            }

            var pathGeometry = new PathGeometry();
            var pathFigure   = new PathFigure {
                IsClosed = true
            };

            var center =
                Center ??
                new Point(
                    outerRadius + StrokeThickness / 2,
                    outerRadius + StrokeThickness / 2);

            // Starting Point
            pathFigure.StartPoint =
                new Point(
                    center.X + Math.Sin(StartAngle * Math.PI / 180) * innerRadius,
                    center.Y - Math.Cos(StartAngle * Math.PI / 180) * innerRadius);

            // Inner Arc
            var innerArcSegment = new ArcSegment
            {
                IsLargeArc = (EndAngle - StartAngle) >= 180.0,
                Point      = new Point(
                    center.X + Math.Sin(EndAngle * Math.PI / 180) * innerRadius,
                    center.Y - Math.Cos(EndAngle * Math.PI / 180) * innerRadius),
                Size           = new Size(innerRadius, innerRadius),
                SweepDirection = SweepDirection.Clockwise
            };

            var lineSegment =
                new LineSegment
            {
                Point = new Point(
                    center.X + Math.Sin(EndAngle * Math.PI / 180) * outerRadius,
                    center.Y - Math.Cos(EndAngle * Math.PI / 180) * outerRadius)
            };

            // Outer Arc
            var outerArcSegment = new ArcSegment
            {
                IsLargeArc = (EndAngle - StartAngle) >= 180.0,
                Point      = new Point(
                    center.X + Math.Sin(StartAngle * Math.PI / 180) * outerRadius,
                    center.Y - Math.Cos(StartAngle * Math.PI / 180) * outerRadius),
                Size           = new Size(outerRadius, outerRadius),
                SweepDirection = SweepDirection.Counterclockwise
            };

            pathFigure.Segments.Add(innerArcSegment);
            pathFigure.Segments.Add(lineSegment);
            pathFigure.Segments.Add(outerArcSegment);
            pathGeometry.Figures.Add(pathFigure);
            InvalidateArrange();
            Data = pathGeometry;
        }
        private void Grid_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (!this.runFlag)
            {
                return;
            }
            this.V0 = Power.Value;
            if (this.V0 == 0)
            {
                MessageBox.Show("You need to set power before shot! Check instruction!");
                return;
            }

            Point point     = e.GetPosition(this);
            var   arrowTop  = Canvas.GetTop(Arrow);
            var   arrowLeft = Canvas.GetLeft(Arrow);

            Arrow.RenderTransform = animatedTranslateTransform;

            this.currentAngle = Math.Atan2(point.Y - arrowTop, point.X - arrowLeft);
            if (this.currentAngle > 1.57 || this.currentAngle < -1.57)
            {
                return;
            }

            var vy = this.V0 * Math.Sin(this.currentAngle);
            var vx = this.V0 * Math.Cos(this.currentAngle);

            var h = Math.Pow(vy, 2) / 2;
            var z = Math.Pow(V0, 2) * Math.Sin(2 * this.currentAngle);

            this.shotTime = TimeSpan.FromSeconds(Math.Abs(2 * this.V0 * Math.Sin(this.currentAngle) / 10));

            var  enemyLeft = Canvas.GetLeft(Enemy);
            var  y1        = arrowTop - this.CalculateY(-enemyLeft);
            Rect r1        = new Rect(enemyLeft, y1, Arrow.ActualWidth, Arrow.ActualHeight);

            if (r1.IntersectsWith(r2))
            {
                this.targeted = true;
            }

            List <double> listOfFunctionPoints = new List <double>();
            double        step  = z / 10;
            double        nextX = step;

            while (z * 1.2 < nextX)
            {
                if (-nextX > this.ActualWidth * 1.5)
                {
                    break;
                }
                listOfFunctionPoints.Add(nextX);
                nextX += step;
            }

            if (listOfFunctionPoints.Count >= 11)
            {
                listOfFunctionPoints.RemoveAt(10);
            }

            if (targeted)
            {
                var firstPointXAfterEnemy = listOfFunctionPoints.FirstOrDefault(x => x < -enemyLeft);
                if (firstPointXAfterEnemy != 0)
                {
                    var index = listOfFunctionPoints.IndexOf(firstPointXAfterEnemy);
                    listOfFunctionPoints = listOfFunctionPoints.Take(index).ToList();
                }

                listOfFunctionPoints.Add(-enemyLeft);
            }

            this.shotTime = TimeSpan.FromSeconds(listOfFunctionPoints.Max() / z * this.shotTime.TotalSeconds);
            PathGeometry animationPath = new PathGeometry();
            PathFigure   pFigure       = new PathFigure();

            pFigure.StartPoint = new Point(0, 0);
            PolyBezierSegment pBezierSegment = new PolyBezierSegment();

            foreach (double pointX in listOfFunctionPoints)
            {
                pBezierSegment.Points.Add(new Point(-pointX, -this.CalculateY(pointX)));
            }

            //// Debug - show calculated values in window.
            //Dane.Visibility = Visibility.Hidden;
            // Dane.Visibility = Visibility.Visible;
            //Dane.Content = $"Enemy left : {enemyLeft}, Hmax = {h}, Zmax={z}, time: {this.shotTime.TotalMilliseconds}, pointX={point.X}, pointY={point.Y}";
            //foreach (var item in pBezierSegment.Points)
            //{
            //   Dane.Content += Environment.NewLine + $"Point : {item.X}, {item.Y}";
            //}

            pFigure.Segments.Add(pBezierSegment);
            animationPath.Figures.Add(pFigure);
            animationPath.Freeze();

            this.ArrowAnimation(animationPath, this.shotTime);
            //Obliczanie rezultatu
            if (!this.targeted)
            {
                Result.Content = "Last shot result : Miss!";
                //Jeśli nie trafimy to nie dodajemy żadnego punktów do naszego wyniku
            }
            else
            {
                //Jeśli trafimy to dodajemy 100 punktów - siła naszego strzału
                Result.Content = "Last shot result : Hit!";
                result        += 100 - this.Power.Value;
            }
        }
示例#44
0
 /// <summary>
 /// Refreshes this instance.
 /// </summary>
 public override void Refresh()
 {
     if (SplinePath != null)
     {
         PathFigure figure = new PathFigure();
         BezierSegment bezierPoints = new BezierSegment();
         PathGeometry pathGeometry = new PathGeometry();
         figure.StartPoint = StartPoint;
         bezierPoints.Point1 = FirstControlPoint;
         bezierPoints.Point2 = EndControlPoint;
         bezierPoints.Point3 = EndPoint;
         figure.Segments.Add(bezierPoints);
         pathGeometry.Figures = new PathFigureCollection() { figure };
         SplinePath.Data = pathGeometry;
     }
 }
示例#45
0
 /// <summary>
 /// Refresh the Series Part
 /// </summary>
 public override void Refresh()
 {
     if (AreaPath != null)
     {
         PathFigure figure = new PathFigure();
         LineSegment startLineSegment = new LineSegment();
         LineSegment areaEndLineSegment = new LineSegment();
         LineSegment endLineSegment = new LineSegment();
         PathGeometry pathGeometry = new PathGeometry();
         figure.StartPoint = StartPoint;
         startLineSegment.Point = AreaStartPoint;
         endLineSegment.Point = EndPoint;
         areaEndLineSegment.Point = AreaEndPoint;
         figure.Segments.Add(startLineSegment);
         figure.Segments.Add(areaEndLineSegment);
         figure.Segments.Add(endLineSegment);
         pathGeometry.Figures = new PathFigureCollection() { figure };
         AreaPath.Data = pathGeometry;
     }
 }
示例#46
0
        /// <summary>
        /// Adds an ellipse to the current path.
        /// </summary>
        public void AddEllipse(double x, double y, double width, double height)
        {
#if CORE
            double w = width / 2;
            double h = height / 2;
            double xc = x + w;
            double yc = y + h;
            _corePath.MoveTo(x + w, y);
            _corePath.QuadrantArcTo(xc, yc, w, h, 1, true);
            _corePath.QuadrantArcTo(xc, yc, w, h, 4, true);
            _corePath.QuadrantArcTo(xc, yc, w, h, 3, true);
            _corePath.QuadrantArcTo(xc, yc, w, h, 2, true);
            _corePath.CloseSubpath();
#endif
#if GDI
            try
            {
                Lock.EnterGdiPlus();
                _gdipPath.AddEllipse((float)x, (float)y, (float)width, (float)height);
            }
            finally { Lock.ExitGdiPlus(); }
#endif
#if WPF || NETFX_CORE
#if !SILVERLIGHT && !NETFX_CORE
            _pathGeometry.AddGeometry(new EllipseGeometry(new Rect(x, y, width, height)));
#else
            var figure = new PathFigure();
            figure.StartPoint = new SysPoint(x, y + height / 2);
            var segment = new ArcSegment
            {
                Point = new SysPoint(x + width, y + height / 2),
                Size = new SysSize(width / 2, height / 2),
                IsLargeArc = true,
                RotationAngle = 180,
                SweepDirection = SweepDirection.Clockwise,
            };
            figure.Segments.Add(segment);
            segment = new ArcSegment
            {
                Point = figure.StartPoint,
                Size = new SysSize(width / 2, height / 2),
                IsLargeArc = true,
                RotationAngle = 180,
                SweepDirection = SweepDirection.Clockwise,
            };
            figure.Segments.Add(segment);
            _pathGeometry.Figures.Add(figure);
#endif
            // StartFigure() isn't needed because AddGeometry() implicitly starts a new figure,
            // but CloseFigure() is needed for the next adding not to continue this figure.
            CloseFigure();
#endif
        }
        /// <summary>
        /// Render callback.
        /// </summary>
        protected override void OnRender(DrawingContext drawingContext)
        {
            CornerRadius cornerRadius = CornerRadius;

            Rect shadowBounds = new Rect(new Point(ShadowDepth, ShadowDepth),
                                         new Size(RenderSize.Width, RenderSize.Height));
            Color color = Color;

            if (shadowBounds.Width > 0 && shadowBounds.Height > 0 && color.A > 0)
            {
                // The shadow is drawn with a dark center the size of the shadow bounds
                // deflated by shadow depth on each side.
                double centerWidth  = shadowBounds.Right - shadowBounds.Left - 2 * ShadowDepth;
                double centerHeight = shadowBounds.Bottom - shadowBounds.Top - 2 * ShadowDepth;

                // Clamp corner radii to be less than 1/2 the side of the inner shadow bounds
                double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5);
                cornerRadius.TopLeft     = Math.Min(cornerRadius.TopLeft, maxRadius);
                cornerRadius.TopRight    = Math.Min(cornerRadius.TopRight, maxRadius);
                cornerRadius.BottomLeft  = Math.Min(cornerRadius.BottomLeft, maxRadius);
                cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius);

                // Get the brushes for the 9 regions
                Brush[] brushes = GetBrushes(color, cornerRadius);

                // Snap grid to device pixels
                double centerTop    = shadowBounds.Top + ShadowDepth;
                double centerLeft   = shadowBounds.Left + ShadowDepth;
                double centerRight  = shadowBounds.Right - ShadowDepth;
                double centerBottom = shadowBounds.Bottom - ShadowDepth;

                // Because of different corner radii there are 6 potential x (or y) lines to snap to
                double[] guidelineSetX = new double[] { centerLeft,
                                                        centerLeft + cornerRadius.TopLeft,
                                                        centerRight - cornerRadius.TopRight,
                                                        centerLeft + cornerRadius.BottomLeft,
                                                        centerRight - cornerRadius.BottomRight,
                                                        centerRight };

                double[] guidelineSetY = new double[] { centerTop,
                                                        centerTop + cornerRadius.TopLeft,
                                                        centerTop + cornerRadius.TopRight,
                                                        centerBottom - cornerRadius.BottomLeft,
                                                        centerBottom - cornerRadius.BottomRight,
                                                        centerBottom };

                drawingContext.PushGuidelineSet(new GuidelineSet(guidelineSetX, guidelineSetY));

                // The corner rectangles are drawn drawn ShadowDepth pixels bigger to
                // account for the blur
                cornerRadius.TopLeft     = cornerRadius.TopLeft + ShadowDepth;
                cornerRadius.TopRight    = cornerRadius.TopRight + ShadowDepth;
                cornerRadius.BottomLeft  = cornerRadius.BottomLeft + ShadowDepth;
                cornerRadius.BottomRight = cornerRadius.BottomRight + ShadowDepth;


                // Draw Top row
                Rect topLeft = new Rect(shadowBounds.Left, shadowBounds.Top, cornerRadius.TopLeft, cornerRadius.TopLeft);
                drawingContext.DrawRectangle(brushes[TopLeft], null, topLeft);

                double topWidth = guidelineSetX[2] - guidelineSetX[1];
                if (topWidth > 0)
                {
                    Rect top = new Rect(guidelineSetX[1], shadowBounds.Top, topWidth, ShadowDepth);
                    drawingContext.DrawRectangle(brushes[Top], null, top);
                }

                Rect topRight = new Rect(guidelineSetX[2], shadowBounds.Top, cornerRadius.TopRight, cornerRadius.TopRight);
                drawingContext.DrawRectangle(brushes[TopRight], null, topRight);

                // Middle row
                double leftHeight = guidelineSetY[3] - guidelineSetY[1];
                if (leftHeight > 0)
                {
                    Rect left = new Rect(shadowBounds.Left, guidelineSetY[1], ShadowDepth, leftHeight);
                    drawingContext.DrawRectangle(brushes[Left], null, left);
                }

                double rightHeight = guidelineSetY[4] - guidelineSetY[2];
                if (rightHeight > 0)
                {
                    Rect right = new Rect(guidelineSetX[5], guidelineSetY[2], ShadowDepth, rightHeight);
                    drawingContext.DrawRectangle(brushes[Right], null, right);
                }

                // Bottom row
                Rect bottomLeft = new Rect(shadowBounds.Left, guidelineSetY[3], cornerRadius.BottomLeft, cornerRadius.BottomLeft);
                drawingContext.DrawRectangle(brushes[BottomLeft], null, bottomLeft);

                double bottomWidth = guidelineSetX[4] - guidelineSetX[3];
                if (bottomWidth > 0)
                {
                    Rect bottom = new Rect(guidelineSetX[3], guidelineSetY[5], bottomWidth, ShadowDepth);
                    drawingContext.DrawRectangle(brushes[Bottom], null, bottom);
                }

                Rect bottomRight = new Rect(guidelineSetX[4], guidelineSetY[4], cornerRadius.BottomRight, cornerRadius.BottomRight);
                drawingContext.DrawRectangle(brushes[BottomRight], null, bottomRight);


                // Fill Center

                // Because the heights of the top/bottom rects and widths of the left/right rects are fixed
                // and the corner rects are drawn with the size of the corner, the center
                // may not be a square.  In this case, create a path to fill the area

                // When the target object's corner radius is 0, only need to draw one rect
                if (cornerRadius.TopLeft == ShadowDepth &&
                    cornerRadius.TopLeft == cornerRadius.TopRight &&
                    cornerRadius.TopLeft == cornerRadius.BottomLeft &&
                    cornerRadius.TopLeft == cornerRadius.BottomRight)
                {
                    // All corners of target are 0, render one large rectangle
                    Rect center = new Rect(guidelineSetX[0], guidelineSetY[0], centerWidth, centerHeight);
                    drawingContext.DrawRectangle(brushes[Center], null, center);
                }
                else
                {
                    // If the corner radius is TL=2, TR=1, BL=0, BR=2 the following shows the shape that needs to be created.
                    //             _________________
                    //            |                 |_
                    //         _ _|                   |
                    //        |                       |
                    //        |                    _ _|
                    //        |                   |
                    //        |___________________|
                    // The missing corners of the shape are filled with the radial gradients drawn above

                    // Define shape counter clockwise
                    PathFigure figure = new PathFigure();

                    if (cornerRadius.TopLeft > ShadowDepth)
                    {
                        figure.StartPoint = new Point(guidelineSetX[1], guidelineSetY[0]);
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[1], guidelineSetY[1]), true));
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[0], guidelineSetY[1]), true));
                    }
                    else
                    {
                        figure.StartPoint = new Point(guidelineSetX[0], guidelineSetY[0]);
                    }

                    if (cornerRadius.BottomLeft > ShadowDepth)
                    {
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[0], guidelineSetY[3]), true));
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[3], guidelineSetY[3]), true));
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[3], guidelineSetY[5]), true));
                    }
                    else
                    {
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[0], guidelineSetY[5]), true));
                    }

                    if (cornerRadius.BottomRight > ShadowDepth)
                    {
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[4], guidelineSetY[5]), true));
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[4], guidelineSetY[4]), true));
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[5], guidelineSetY[4]), true));
                    }
                    else
                    {
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[5], guidelineSetY[5]), true));
                    }


                    if (cornerRadius.TopRight > ShadowDepth)
                    {
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[5], guidelineSetY[2]), true));
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[2], guidelineSetY[2]), true));
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[2], guidelineSetY[0]), true));
                    }
                    else
                    {
                        figure.Segments.Add(new LineSegment(new Point(guidelineSetX[5], guidelineSetY[0]), true));
                    }

                    figure.IsClosed = true;
                    figure.Freeze();

                    PathGeometry geometry = new PathGeometry();
                    geometry.Figures.Add(figure);
                    geometry.Freeze();

                    drawingContext.DrawGeometry(brushes[Center], null, geometry);
                }

                drawingContext.Pop();
            }
        }
示例#48
0
        /// <summary>
        /// Starts a new figure without closing the current figure.
        /// </summary>
        public void StartFigure()
        {
#if CORE
            // TODO: ???
#endif
#if GDI
            try
            {
                Lock.EnterGdiPlus();
                _gdipPath.StartFigure();
            }
            finally { Lock.ExitGdiPlus(); }
#endif
#if WPF || NETFX_CORE
            PathFigure figure = CurrentPathFigure;
            if (figure.Segments.Count != 0)
            {
                figure = new PathFigure();
                _pathGeometry.Figures.Add(figure);
            }
#endif
        }
示例#49
0
        public void MatrixAnimationUsingPathDoesRotateWithTangentExample()
        {
            // Create a NameScope for the page so that
            // we can use Storyboards.
            NameScope.SetNameScope(MainGrid, new NameScope());

            // Create a button.
            Map.MapBlock aButton = new Map.MapBlock();
            aButton.LeftSideVisable  = true;
            aButton.RightSideVisable = true;
            // Create a MatrixTransform. This transform
            // will be used to move the button.
            MatrixTransform buttonMatrixTransform = new MatrixTransform();

            aButton.RenderTransform = buttonMatrixTransform;

            // Register the transform's name with the page
            // so that it can be targeted by a Storyboard.
            MainGrid.RegisterName("ButtonMatrixTransform", buttonMatrixTransform);

            // Create a Canvas to contain the button
            // and add it to the page.
            // Although this example uses a Canvas,
            // any type of panel will work.
            Canvas mainPanel = new Canvas();

            mainPanel.Width  = 400;
            mainPanel.Height = 400;
            mainPanel.Children.Add(aButton);
            MainGrid.Children.Add(mainPanel);

            // Create the animation path.
            PathGeometry animationPath = new PathGeometry();
            PathFigure   pFigure       = new PathFigure();

            pFigure.StartPoint = new Point(10, 100);
            PolyBezierSegment pBezierSegment = new PolyBezierSegment();

            pBezierSegment.Points.Add(new Point(35, 0));
            pBezierSegment.Points.Add(new Point(135, 0));
            pBezierSegment.Points.Add(new Point(160, 100));
            pBezierSegment.Points.Add(new Point(180, 190));
            pBezierSegment.Points.Add(new Point(285, 200));
            pBezierSegment.Points.Add(new Point(310, 100));
            pFigure.Segments.Add(pBezierSegment);
            animationPath.Figures.Add(pFigure);

            // Freeze the PathGeometry for performance benefits.
            animationPath.Freeze();

            // Create a MatrixAnimationUsingPath to move the
            // button along the path by animating
            // its MatrixTransform.
            MatrixAnimationUsingPath matrixAnimation =
                new MatrixAnimationUsingPath();

            matrixAnimation.PathGeometry   = animationPath;
            matrixAnimation.Duration       = TimeSpan.FromSeconds(5);
            matrixAnimation.RepeatBehavior = RepeatBehavior.Forever;

            // Set the animation's DoesRotateWithTangent property
            // to true so that rotates the rectangle in addition
            // to moving it.
            matrixAnimation.DoesRotateWithTangent = true;

            // Set the animation to target the Matrix property
            // of the MatrixTransform named "ButtonMatrixTransform".
            Storyboard.SetTargetName(matrixAnimation, "ButtonMatrixTransform");
            Storyboard.SetTargetProperty(matrixAnimation,
                                         new PropertyPath(MatrixTransform.MatrixProperty));

            // Create a Storyboard to contain and apply the animation.
            Storyboard pathAnimationStoryboard = new Storyboard();

            pathAnimationStoryboard.Children.Add(matrixAnimation);

            // Start the storyboard when the button is loaded.
            aButton.Loaded += delegate(object sender, RoutedEventArgs e)
            {
                // Start the storyboard.
                pathAnimationStoryboard.Begin(MainGrid);
            };
        }
示例#50
0
        /// <summary>
        /// Draws a collection of polygons, where all polygons have the same stroke and fill.
        /// This performs better than calling DrawPolygon multiple times.
        /// </summary>
        /// <param name="polygons">The polygons.</param>
        /// <param name="fill">The fill color.</param>
        /// <param name="stroke">The stroke color.</param>
        /// <param name="thickness">The stroke thickness.</param>
        /// <param name="dashArray">The dash array.</param>
        /// <param name="lineJoin">The line join type.</param>
        /// <param name="aliased">if set to <c>true</c> the shape will be aliased.</param>
        public void DrawPolygons(
            IList<IList<ScreenPoint>> polygons,
            OxyColor fill,
            OxyColor stroke,
            double thickness,
            double[] dashArray,
            LineJoin lineJoin,
            bool aliased)
        {
            var path = new Path();
            this.SetStroke(path, stroke, thickness, lineJoin, dashArray, aliased);
            if (fill.IsVisible())
            {
                path.Fill = this.GetCachedBrush(fill);
            }

            var pg = new PathGeometry { FillRule = FillRule.Nonzero };
            foreach (var polygon in polygons)
            {
                var figure = new PathFigure { IsClosed = true };
                bool first = true;
                foreach (var p in polygon)
                {
                    if (first)
                    {
                        figure.StartPoint = p.ToPoint(aliased);
                        first = false;
                    }
                    else
                    {
                        figure.Segments.Add(new LineSegment { Point = p.ToPoint(aliased) });
                    }
                }

                pg.Figures.Add(figure);
            }

            path.Data = pg;
            this.Add(path);
        }
示例#51
0
        private void Run_Click(object sender, RoutedEventArgs e)
        {
            var VMCountriesPartStyle = "VM_CountriesPartStyle";
            var binding = new Binding(VMCountriesPartStyle)
            {
                Mode = BindingMode.OneWay
            };

            this.SetBinding(CountriesPartStyleProperty, binding);

            float pieWidth = 250, pieHeight = 250, centerX = pieWidth / 2, centerY = pieHeight / 2, radius = pieWidth / 2;

            mainCanvas.Width  = pieWidth;
            mainCanvas.Height = pieHeight;

            Categories = new List <Category>();
            List <SolidColorBrush> colors = new List <SolidColorBrush>
            {
                new SolidColorBrush((Color)ColorConverter.ConvertFromString("#80bfff")), // blue
                new SolidColorBrush((Color)ColorConverter.ConvertFromString("#ff99cc")), // pink
                new SolidColorBrush((Color)ColorConverter.ConvertFromString("#ffcc99")), // orenge
                new SolidColorBrush((Color)ColorConverter.ConvertFromString("#66ff66")), // green
                new SolidColorBrush((Color)ColorConverter.ConvertFromString("#d9b3ff")), // perpul
            };
            int i = 0;

            foreach (KeyValuePair <string, int> entry in CountriesPartStyle)
            {
                Category category = new Category
                {
                    Title      = entry.Key,
                    Percentage = entry.Value,
                    ColorBrush = colors[i],
                };
                Categories.Add(category);
                i++;

                // Check witch country is the country with  the biggest Percentage.
                if (entry.Value > maxPart)
                {
                    maxPart      = entry.Value;
                    contryResult = entry.Key;
                    color        = colors[i - 1].ToString();
                }
            }

            detailsItemsControl.ItemsSource = Categories;

            // Draw pie
            float angle = 0, prevAngle = 0;

            foreach (var category in Categories)
            {
                double line1X = (radius * Math.Cos(angle * Math.PI / 180)) + centerX;
                double line1Y = (radius * Math.Sin(angle * Math.PI / 180)) + centerY;

                angle = category.Percentage * (float)360 / 100 + prevAngle;
                Debug.WriteLine(angle);

                double arcX = (radius * Math.Cos(angle * Math.PI / 180)) + centerX;
                double arcY = (radius * Math.Sin(angle * Math.PI / 180)) + centerY;

                var    line1Segment = new LineSegment(new Point(line1X, line1Y), false);
                double arcWidth = radius, arcHeight = radius;
                bool   isLargeArc = category.Percentage > 50;
                var    arcSegment = new ArcSegment()
                {
                    Size           = new Size(arcWidth, arcHeight),
                    Point          = new Point(arcX, arcY),
                    SweepDirection = SweepDirection.Clockwise,
                    IsLargeArc     = isLargeArc,
                };
                var line2Segment = new LineSegment(new Point(centerX, centerY), false);

                var pathFigure = new PathFigure(
                    new Point(centerX, centerY),
                    new List <PathSegment>()
                {
                    line1Segment,
                    arcSegment,
                    line2Segment,
                },
                    true);

                var pathFigures = new List <PathFigure>()
                {
                    pathFigure,
                };
                var pathGeometry = new PathGeometry(pathFigures);
                var path         = new Path()
                {
                    Fill = category.ColorBrush,
                    Data = pathGeometry,
                };
                mainCanvas.Children.Add(path);

                prevAngle = angle;


                // Draw outlines
                var outline1 = new Line()
                {
                    X1              = centerX,
                    Y1              = centerY,
                    X2              = line1Segment.Point.X,
                    Y2              = line1Segment.Point.Y,
                    Stroke          = Brushes.White,
                    StrokeThickness = 5,
                };
                var outline2 = new Line()
                {
                    X1              = centerX,
                    Y1              = centerY,
                    X2              = arcSegment.Point.X,
                    Y2              = arcSegment.Point.Y,
                    Stroke          = Brushes.White,
                    StrokeThickness = 5,
                };

                mainCanvas.Children.Add(outline1);
                mainCanvas.Children.Add(outline2);
            }

            // Update result view.
            resultsView.Visibility = Visibility.Visible;
            resultVal.Text         = contryResult;
            resultVal.Background   = new BrushConverter().ConvertFromString(color) as SolidColorBrush;

            maxPart = 0;
        }
示例#52
0
 private void DrawBorder(DrawingContext dc, ref Rect bounds)
 {
     if (bounds.Width >= 5.0 && bounds.Height >= 5.0)
     {
         Brush brush = this.BorderBrush;
         Pen   pen   = null;
         if (brush != null)
         {
             if (ImageButtonChromeControl._commonBorderPen == null)
             {
                 lock (ImageButtonChromeControl._resourceAccess)
                 {
                     if (ImageButtonChromeControl._commonBorderPen == null)
                     {
                         if (!brush.IsFrozen && brush.CanFreeze)
                         {
                             brush = brush.Clone();
                             brush.Freeze();
                         }
                         Pen pen2 = new Pen(brush, 1.0);
                         if (pen2.CanFreeze)
                         {
                             pen2.Freeze();
                             ImageButtonChromeControl._commonBorderPen = pen2;
                         }
                     }
                 }
             }
             if (ImageButtonChromeControl._commonBorderPen != null && brush == ImageButtonChromeControl._commonBorderPen.Brush)
             {
                 pen = ImageButtonChromeControl._commonBorderPen;
             }
             else
             {
                 if (!brush.IsFrozen && brush.CanFreeze)
                 {
                     brush = brush.Clone();
                     brush.Freeze();
                 }
                 pen = new Pen(brush, 1.0);
                 if (pen.CanFreeze)
                 {
                     pen.Freeze();
                 }
             }
         }
         Pen borderOverlayPen = this.BorderOverlayPen;
         if (pen != null || borderOverlayPen != null)
         {
             if (this.RoundCorners)
             {
                 Rect rectangle = new Rect(bounds.Left + 0.5, bounds.Top + 0.5, bounds.Width - 1.0, bounds.Height - 1.0);
                 if (base.IsEnabled && pen != null)
                 {
                     dc.DrawRoundedRectangle(null, pen, rectangle, 2.75, 2.75);
                 }
                 if (borderOverlayPen != null)
                 {
                     dc.DrawRoundedRectangle(null, borderOverlayPen, rectangle, 2.75, 2.75);
                     return;
                 }
             }
             else
             {
                 PathFigure pathFigure = new PathFigure();
                 pathFigure.StartPoint = new Point(0.5, 0.5);
                 pathFigure.Segments.Add(new LineSegment(new Point(0.5, bounds.Bottom - 0.5), true));
                 pathFigure.Segments.Add(new LineSegment(new Point(bounds.Right - 2.5, bounds.Bottom - 0.5), true));
                 pathFigure.Segments.Add(new ArcSegment(new Point(bounds.Right - 0.5, bounds.Bottom - 2.5), new Size(2.0, 2.0), 0.0, false, SweepDirection.Counterclockwise, true));
                 pathFigure.Segments.Add(new LineSegment(new Point(bounds.Right - 0.5, bounds.Top + 2.5), true));
                 pathFigure.Segments.Add(new ArcSegment(new Point(bounds.Right - 2.5, bounds.Top + 0.5), new Size(2.0, 2.0), 0.0, false, SweepDirection.Counterclockwise, true));
                 pathFigure.IsClosed = true;
                 PathGeometry pathGeometry = new PathGeometry();
                 pathGeometry.Figures.Add(pathFigure);
                 if (base.IsEnabled && pen != null)
                 {
                     dc.DrawGeometry(null, pen, pathGeometry);
                 }
                 if (borderOverlayPen != null)
                 {
                     dc.DrawGeometry(null, borderOverlayPen, pathGeometry);
                 }
             }
         }
     }
 }
        protected override void OnViewportChanged(ViewportChangedEventArgs e)
        {
            var projection = ParentMap.MapProjection;

            if (projection.IsNormalCylindrical)
            {
                if (path == null)
                {
                    path = new Path {
                        Data = new PathGeometry()
                    };
                    path.SetBinding(Shape.StrokeProperty, GetBinding(StrokeProperty, nameof(Stroke)));
                    path.SetBinding(Shape.StrokeThicknessProperty, GetBinding(StrokeThicknessProperty, nameof(StrokeThickness)));
                    path.SetBinding(Shape.StrokeDashArrayProperty, GetBinding(StrokeDashArrayProperty, nameof(StrokeDashArray)));
                    path.SetBinding(Shape.StrokeDashOffsetProperty, GetBinding(StrokeDashOffsetProperty, nameof(StrokeDashOffset)));
                    path.SetBinding(Shape.StrokeDashCapProperty, GetBinding(StrokeDashCapProperty, nameof(StrokeDashCap)));
                    Children.Add(path);
                }

                var bounds       = projection.ViewportRectToBoundingBox(new Rect(0d, 0d, ParentMap.RenderSize.Width, ParentMap.RenderSize.Height));
                var lineDistance = GetLineDistance();

                var labelStart = new Location(
                    Math.Ceiling(bounds.South / lineDistance) * lineDistance,
                    Math.Ceiling(bounds.West / lineDistance) * lineDistance);

                var labelEnd = new Location(
                    Math.Floor(bounds.North / lineDistance) * lineDistance,
                    Math.Floor(bounds.East / lineDistance) * lineDistance);

                var lineStart = new Location(
                    Math.Min(Math.Max(labelStart.Latitude - lineDistance, -projection.MaxLatitude), projection.MaxLatitude),
                    labelStart.Longitude - lineDistance);

                var lineEnd = new Location(
                    Math.Min(Math.Max(labelEnd.Latitude + lineDistance, -projection.MaxLatitude), projection.MaxLatitude),
                    labelEnd.Longitude + lineDistance);

                var geometry = (PathGeometry)path.Data;
                geometry.Figures.Clear();

                for (var lat = labelStart.Latitude; lat <= bounds.North; lat += lineDistance)
                {
                    var figure = new PathFigure
                    {
                        StartPoint = projection.LocationToViewportPoint(new Location(lat, lineStart.Longitude)),
                        IsClosed   = false,
                        IsFilled   = false
                    };

                    figure.Segments.Add(new LineSegment
                    {
                        Point = projection.LocationToViewportPoint(new Location(lat, lineEnd.Longitude))
                    });

                    geometry.Figures.Add(figure);
                }

                for (var lon = labelStart.Longitude; lon <= bounds.East; lon += lineDistance)
                {
                    var figure = new PathFigure
                    {
                        StartPoint = projection.LocationToViewportPoint(new Location(lineStart.Latitude, lon)),
                        IsClosed   = false,
                        IsFilled   = false
                    };

                    figure.Segments.Add(new LineSegment
                    {
                        Point = projection.LocationToViewportPoint(new Location(lineEnd.Latitude, lon))
                    });

                    geometry.Figures.Add(figure);
                }

                var labelFormat = GetLabelFormat(lineDistance);
                var childIndex  = 1; // 0 for Path

                for (var lat = labelStart.Latitude; lat <= bounds.North; lat += lineDistance)
                {
                    for (var lon = labelStart.Longitude; lon <= bounds.East; lon += lineDistance)
                    {
                        TextBlock label;

                        if (childIndex < Children.Count)
                        {
                            label = (TextBlock)Children[childIndex];
                        }
                        else
                        {
                            var renderTransform = new TransformGroup();
                            renderTransform.Children.Add(new TranslateTransform());
                            renderTransform.Children.Add(ParentMap.RotateTransform);
                            renderTransform.Children.Add(new TranslateTransform());

                            label = new TextBlock {
                                RenderTransform = renderTransform
                            };
                            if (FontFamily != null)
                            {
                                label.SetBinding(TextBlock.FontFamilyProperty, GetBinding(FontFamilyProperty, nameof(FontFamily)));
                            }
                            label.SetBinding(TextBlock.FontSizeProperty, GetBinding(FontSizeProperty, nameof(FontSize)));
                            label.SetBinding(TextBlock.FontStyleProperty, GetBinding(FontStyleProperty, nameof(FontStyle)));
                            label.SetBinding(TextBlock.FontStretchProperty, GetBinding(FontStretchProperty, nameof(FontStretch)));
                            label.SetBinding(TextBlock.FontWeightProperty, GetBinding(FontWeightProperty, nameof(FontWeight)));
                            label.SetBinding(TextBlock.ForegroundProperty, GetBinding(ForegroundProperty, nameof(Foreground)));

                            Children.Add(label);
                        }

                        childIndex++;

                        label.Text = GetLabelText(lat, labelFormat, "NS") + "\n" + GetLabelText(Location.NormalizeLongitude(lon), labelFormat, "EW");
                        label.Tag  = new Location(lat, lon);
                        label.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));

                        var translateTransform = (TranslateTransform)((TransformGroup)label.RenderTransform).Children[0];
                        translateTransform.X = StrokeThickness / 2d + 2d;
                        translateTransform.Y = -label.DesiredSize.Height / 2d;
                    }

                    while (Children.Count > childIndex)
                    {
                        Children.RemoveAt(Children.Count - 1);
                    }
                }

                // don't use MapPanel.Location because labels may be at more than 180° distance from map center

                for (int i = 1; i < Children.Count; i++)
                {
                    var label             = (TextBlock)Children[i];
                    var location          = (Location)label.Tag;
                    var viewportTransform = (TranslateTransform)((TransformGroup)label.RenderTransform).Children[2];
                    var viewportPosition  = projection.LocationToViewportPoint(location);
                    viewportTransform.X = viewportPosition.X;
                    viewportTransform.Y = viewportPosition.Y;
                }
            }
            else if (path != null)
            {
                path = null;
                Children.Clear();
            }

            base.OnViewportChanged(e);
        }
示例#54
0
        private static Geometry ProcessPathData(List<PathInfo> pis)
        {
            PathGeometry geometry = new PathGeometry();
            PathFigure figure = null;
            foreach (var pi in pis)
            {
                switch (pi.segmentType)
                {
                    case SegmentType.Move:
                        figure = new PathFigure()
                        {
                            StartPoint = pi.point
                        };
                        geometry.Figures.Add(figure);
                        break;
                    case SegmentType.Line:
                        figure.Segments.Add(new LineSegment()
                        {
                            Point = pi.point
                        });
                        break;
                    case SegmentType.Arc:
                        figure.Segments.Add(new ArcSegment()
                        {
                            Size = new Size(pi.size.X, pi.size.Y),
                            IsLargeArc = pi.isLargeArc,
                            Point = pi.point,
                            RotationAngle = pi.angle,
                            SweepDirection = pi.isSweepDirectionClockwise ? SweepDirection.Clockwise : SweepDirection.Counterclockwise
                        });
                        break;
                    case SegmentType.Close:
                        figure.IsClosed = true;
                        break;
                    default:
                        break;
                }
            }

            return geometry;
        }
示例#55
0
        Visual CreateQuadraticBezierSegments()
        {
            DrawingContext dc;
            DrawingVisual  dv = PrepareDrawingVisual(out dc);

            Point startPoint = new Point(20, 120);

            Point[]      points = { new Point(30, 20), new Point(150, 130), new Point(200, 20), new Point(215, 60) };
            PathGeometry path;
            PathFigure   figure;
            Brush        brush = Brushes.DarkOrange;
            Pen          pen   = new Pen(Brushes.DarkBlue, 3);

            BeginBox(dc, 1, BoxOptions.Tile, "stroke");
            path = new PathGeometry();
            path.Figures.Add(figure = new PathFigure());
            figure.StartPoint       = startPoint;
            figure.Segments.Add(new PolyQuadraticBezierSegment(points, true));
            dc.DrawGeometry(null, pen, path);
            EndBox(dc);

            BeginBox(dc, 2, BoxOptions.Tile, "stroke, figure closed");
            path = new PathGeometry();
            path.Figures.Add(figure = new PathFigure());
            figure.StartPoint       = startPoint;
            figure.IsClosed         = true;
            figure.Segments.Add(new PolyQuadraticBezierSegment(points, true));
            dc.DrawGeometry(null, pen, path);
            EndBox(dc);

            BeginBox(dc, 3, BoxOptions.Tile, "fill");
            path = new PathGeometry();
            path.Figures.Add(figure = new PathFigure());
            figure.StartPoint       = startPoint;
            figure.Segments.Add(new PolyQuadraticBezierSegment(points, true));
            dc.DrawGeometry(brush, null, path);
            EndBox(dc);

            BeginBox(dc, 4, BoxOptions.Tile, "fill, figure closed");
            path = new PathGeometry();
            path.Figures.Add(figure = new PathFigure());
            figure.StartPoint       = startPoint;
            figure.IsClosed         = true;
            figure.Segments.Add(new PolyQuadraticBezierSegment(points, true));
            dc.DrawGeometry(brush, null, path);
            EndBox(dc);

            BeginBox(dc, 5, BoxOptions.Tile, "fill & stroke");
            path = new PathGeometry();
            path.Figures.Add(figure = new PathFigure());
            figure.StartPoint       = startPoint;
            figure.Segments.Add(new PolyQuadraticBezierSegment(points, true));
            dc.DrawGeometry(brush, pen, path);
            EndBox(dc);

            BeginBox(dc, 6, BoxOptions.Tile, "fill & stroke, figure closed");
            path = new PathGeometry();
            path.Figures.Add(figure = new PathFigure());
            figure.StartPoint       = startPoint;
            figure.IsClosed         = true;
            figure.Segments.Add(new PolyQuadraticBezierSegment(points, true));
            dc.DrawGeometry(brush, pen, path);
            EndBox(dc);

            //BeginBox(dc, 7);
            //EndBox(dc);

            //BeginBox(dc, 8);
            //EndBox(dc);

            dc.Close();
            return(dv);
        }
示例#56
0
        public void DrawArc(float cx, float cy, float radius, float startAngle, float endAngle, float w)
        {
            var s = GetNextShape(TypeId.Arc);
            var e = s.Element as Path;

            if (e.Data == null || s.X != cx || s.Y != cy || s.Radius != radius || s.Width != startAngle || s.Height != endAngle) {
                s.X = cx;
                s.Y = cy;
                s.Radius = radius;
                s.Width = startAngle;
                s.Height = endAngle;

                var fig = new PathFigure();
                var sa = -startAngle;
                var ea = -endAngle;
                fig.StartPoint = new Point(
                    cx + radius * Math.Cos(sa),
                    cy + radius * Math.Sin(sa));
                fig.Segments.Add(new ArcSegment() {
                    Point = new Point(
                        cx + radius * Math.Cos(ea),
                        cy + radius * Math.Sin(ea)),
                    Size = new Size(radius, radius),
                    SweepDirection = SweepDirection.Counterclockwise,
                });
                var geo = new PathGeometry();
                geo.Figures.Add(fig);
                e.Data = geo;
            }

            if (s.Thickness != w) {
                s.Thickness = w;
                e.StrokeThickness = w;
            }

            if (s.Color != _currentColor || s.DrawOp != DrawOp.Draw) {
                s.Color = _currentColor;
                s.DrawOp = DrawOp.Draw;
                e.Stroke = _currentColor.GetBrush();
                e.Fill = null;
            }
        }
        protected override void OnViewportChanged()
        {
            var bounds = ParentMap.ViewportTransform.Inverse.TransformBounds(new Rect(new Point(), ParentMap.RenderSize));
            var start = ParentMap.MapTransform.Transform(new Point(bounds.X, bounds.Y));
            var end = ParentMap.MapTransform.Transform(new Point(bounds.X + bounds.Width, bounds.Y + bounds.Height));
            var minSpacing = MinLineSpacing * 360d / (Math.Pow(2d, ParentMap.ZoomLevel) * 256d);
            var spacing = LineSpacings[LineSpacings.Length - 1];

            if (spacing >= minSpacing)
            {
                spacing = LineSpacings.FirstOrDefault(s => s >= minSpacing);
            }

            var labelStart = new Location(
                Math.Ceiling(start.Latitude / spacing) * spacing,
                Math.Ceiling(start.Longitude / spacing) * spacing);

            var labelEnd = new Location(
                Math.Floor(end.Latitude / spacing) * spacing,
                Math.Floor(end.Longitude / spacing) * spacing);

            var lineStart = new Location(
                Math.Min(Math.Max(labelStart.Latitude - spacing, -ParentMap.MapTransform.MaxLatitude), ParentMap.MapTransform.MaxLatitude),
                labelStart.Longitude - spacing);

            var lineEnd = new Location(
                Math.Min(Math.Max(labelEnd.Latitude + spacing, -ParentMap.MapTransform.MaxLatitude), ParentMap.MapTransform.MaxLatitude),
                labelEnd.Longitude + spacing);

            if (!lineStart.Equals(graticuleStart) || !lineEnd.Equals(graticuleEnd))
            {
                graticuleStart = lineStart;
                graticuleEnd = lineEnd;

                var geometry = (PathGeometry)path.Data;
                geometry.Figures.Clear();
                geometry.Transform = ParentMap.ViewportTransform;

                for (var lat = labelStart.Latitude; lat <= end.Latitude; lat += spacing)
                {
                    var figure = new PathFigure
                    {
                        StartPoint = ParentMap.MapTransform.Transform(new Location(lat, lineStart.Longitude)),
                        IsClosed = false,
                        IsFilled = false
                    };

                    figure.Segments.Add(new LineSegment
                    {
                        Point = ParentMap.MapTransform.Transform(new Location(lat, lineEnd.Longitude)),
                    });

                    geometry.Figures.Add(figure);
                }

                for (var lon = labelStart.Longitude; lon <= end.Longitude; lon += spacing)
                {
                    var figure = new PathFigure
                    {
                        StartPoint = ParentMap.MapTransform.Transform(new Location(lineStart.Latitude, lon)),
                        IsClosed = false,
                        IsFilled = false
                    };

                    figure.Segments.Add(new LineSegment
                    {
                        Point = ParentMap.MapTransform.Transform(new Location(lineEnd.Latitude, lon)),
                    });

                    geometry.Figures.Add(figure);
                }

                var childIndex = 1; // 0 for Path
                var format = spacing < 1d ? "{0} {1}°{2:00}'" : "{0} {1}°";

                for (var lat = labelStart.Latitude; lat <= end.Latitude; lat += spacing)
                {
                    for (var lon = labelStart.Longitude; lon <= end.Longitude; lon += spacing)
                    {
                        TextBlock label;

                        if (childIndex < Children.Count)
                        {
                            label = (TextBlock)Children[childIndex];
                        }
                        else
                        {
                            var renderTransform = new TransformGroup();
                            renderTransform.Children.Add(new TranslateTransform());
                            renderTransform.Children.Add(ParentMap.RotateTransform);
                            renderTransform.Children.Add(new TranslateTransform());

                            label = new TextBlock
                            {
                                RenderTransform = renderTransform
                            };

                            label.SetBinding(TextBlock.ForegroundProperty, new Binding
                            {
                                Source = this,
                                Path = new PropertyPath("Foreground")
                            });

                            Children.Add(label);
                        }

                        childIndex++;

                        if (FontFamily != null)
                        {
                            label.FontFamily = FontFamily;
                        }

                        label.FontSize = FontSize;
                        label.FontStyle = FontStyle;
                        label.FontStretch = FontStretch;
                        label.FontWeight = FontWeight;
                        label.Text = string.Format("{0}\n{1}", CoordinateString(lat, format, "NS"), CoordinateString(Location.NormalizeLongitude(lon), format, "EW"));
                        label.Tag = new Location(lat, lon);
                        label.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));

                        var translateTransform = (TranslateTransform)((TransformGroup)label.RenderTransform).Children[0];
                        translateTransform.X = StrokeThickness / 2d + 2d;
                        translateTransform.Y = -label.DesiredSize.Height / 2d;
                    }
                }

                while (Children.Count > childIndex)
                {
                    Children.RemoveAt(Children.Count - 1);
                }
            }

            // don't use MapPanel.Location because labels may be at more than 180° distance from map center

            for (int i = 1; i < Children.Count; i++)
            {
                var label = (TextBlock)Children[i];
                var location = (Location)label.Tag;
                var viewportTransform = (TranslateTransform)((TransformGroup)label.RenderTransform).Children[2];
                var viewportPosition = ParentMap.LocationToViewportPoint(location);
                viewportTransform.X = viewportPosition.X;
                viewportTransform.Y = viewportPosition.Y;
            }

            base.OnViewportChanged();
        }
示例#58
0
        ShapeData DoArc(float cx, float cy, float radius, float startAngle, float endAngle)
        {
            var s = GetNextShape (TypeId.Arc);
            var e = s.Element as Path;

            if (e.Data == null || s.X != cx || s.Y != cy || s.Radius != radius || s.Width != startAngle || s.Height != endAngle) {
                s.X = cx;
                s.Y = cy;
                s.Radius = radius;
                s.Width = startAngle;
                s.Height = endAngle;

                var fig = new PathFigure();
                var sa = -startAngle;
                var ea = -endAngle;
                fig.StartPoint = new Point(
                    cx + radius * Math.Cos(sa),
                    cy + radius * Math.Sin(sa));
                fig.Segments.Add(new ArcSegment() {
                    Point = new Point(
                        cx + radius * Math.Cos(ea),
                        cy + radius * Math.Sin(ea)),
                    Size = new Size(radius, radius),
                    SweepDirection = SweepDirection.Counterclockwise,
                });
                var geo = new PathGeometry();
                geo.Figures.Add(fig);
                e.Data = geo;
            }

            return s;
        }
示例#59
0
        /// <summary>
        /// Creates a path geometry from a polygon.
        /// </summary>
        public static PathGeometry CreatePolygonGeometry(SysPoint[] points, XFillMode fillMode, bool closed)
        {
            PolyLineSegment seg = new PolyLineSegment();
            int count = points.Length;
            // For correct drawing the start point of the segment must not be the same as the first point.
            for (int idx = 1; idx < count; idx++)
                seg.Points.Add(new SysPoint(points[idx].X, points[idx].Y));
#if !SILVERLIGHT &&  !NETFX_CORE
            seg.IsStroked = true;
#endif
            PathFigure fig = new PathFigure();
            fig.StartPoint = new SysPoint(points[0].X, points[0].Y);
            fig.Segments.Add(seg);
            fig.IsClosed = closed;
            PathGeometry geo = new PathGeometry();
            geo.FillRule = fillMode == XFillMode.Winding ? FillRule.Nonzero : FillRule.EvenOdd;
            geo.Figures.Add(fig);
            return geo;
        }
示例#60
-1
        public PathGeometry CloneDeep(PathGeometry pathGeometry)
        {
            var newPathGeometry = new PathGeometry();
            foreach (var figure in pathGeometry.Figures)
            {
                var newFigure = new PathFigure();
                newFigure.StartPoint = figure.StartPoint;
                // Even figures have to be deep cloned. Assigning them directly will result in
                //  an InvalidOperationException being thrown with the message "Element is already the child of another element."
                foreach (var segment in figure.Segments)
                {
                    // I only impemented cloning the abstract PathSegments to one implementation, 
                    //  the PolyLineSegment class. If your paths use other kinds of segments, you'll need
                    //  to implement that kind of coding yourself.
                    var segmentAsPolyLineSegment = segment as PolyLineSegment;
                    if (segmentAsPolyLineSegment != null)
                    {
                        var newSegment = new PolyLineSegment();
                        foreach (var point in segmentAsPolyLineSegment.Points)
                        {
                            newSegment.Points.Add(point);
                        }
                        newFigure.Segments.Add(newSegment);
                    }

                    var segmentAsLineSegment = segment as LineSegment;
                    if (segmentAsLineSegment != null)
                    {
                        var newSegment = new LineSegment();
                        newSegment.Point = segmentAsLineSegment.Point;
                        newFigure.Segments.Add(newSegment);
                    }

                    var segmentAsArcSegment = segment as ArcSegment;
                    if (segmentAsArcSegment != null)
                    {
                        var newSegment = new ArcSegment();
                        newSegment.Point = segmentAsArcSegment.Point;
                        newSegment.SweepDirection = segmentAsArcSegment.SweepDirection;
                        newSegment.RotationAngle = segmentAsArcSegment.RotationAngle;
                        newSegment.IsLargeArc = segmentAsArcSegment.IsLargeArc;
                        newSegment.Size = segmentAsArcSegment.Size;
                        newFigure.Segments.Add(newSegment);
                    }
                }
                newPathGeometry.Figures.Add(newFigure);
            }
            return newPathGeometry;
        }