protected override Size ArrangeOverride(Size finalSize) { if (GetValues(this) != null) { double total = 0.0; for (int i = 0; i < InternalChildren.Count; i++) { total += (double)(GetValues(this)[i]); } double offsetAngle = 0.0; double radius = finalSize.Width < finalSize.Height ? finalSize.Width / 2 : finalSize.Height / 2; //radius -= 2; Point beginFigure = new Point(finalSize.Width / 2, finalSize.Height / 2); Point lineToBeforeTransform = new Point(beginFigure.X + radius, beginFigure.Y); for (int i = 0; i < InternalChildren.Count; i++) { ContentControl container = InternalChildren[i] as ContentControl; double wedgeAngle = (double)(GetValues(this)[i]) * 360 / total; RotateTransform rt = new RotateTransform(offsetAngle, beginFigure.X, beginFigure.Y); container.SetValue(PiePanel.BeginFigurePointProperty, beginFigure); container.SetValue(PiePanel.LineToPointProperty, rt.Transform(lineToBeforeTransform)); container.SetValue(PiePanel.WedgeAngleProperty, wedgeAngle); offsetAngle += wedgeAngle; Rect r = new Rect(finalSize); container.Arrange(r); } } return finalSize; }
public StreamGeometry GetClipGeometry(Size arrangeBounds) { StreamGeometry clip = new StreamGeometry(); StreamGeometryContext clipGC = clip.Open(); clipGC.BeginFigure(BeginFigurePoint, true, true); clipGC.LineTo(LineToPoint, false, true); Vector v = LineToPoint - BeginFigurePoint; RotateTransform rt = new RotateTransform(WedgeAngle, BeginFigurePoint.X, BeginFigurePoint.Y); bool isLargeArc = WedgeAngle >180.0; clipGC.ArcTo(rt.Transform(LineToPoint), new Size(v.Length, v.Length), WedgeAngle, isLargeArc, SweepDirection.Clockwise, false, true); clipGC.Close(); return clip; }
protected override void OnRender(DrawingContext drawingContext) { base.OnRender(drawingContext); Rect rect = new Rect(0.0, 0.0, base.ActualWidth, base.ActualHeight); JapaneseTextSource source = new JapaneseTextSource(); source.Text = this.Text; JapaneseTextParagraphProperties textParagraphProperties = this.MakeTextProperties(); source.JapaneseTextRunProperties = (JapaneseTextRunProperties)textParagraphProperties.DefaultTextRunProperties; source.IsVarticalWriting = textParagraphProperties.IsVerticalWriting; if (textParagraphProperties.DefaultTextRunProperties.BackgroundBrush != null) { drawingContext.DrawRectangle(textParagraphProperties.DefaultTextRunProperties.BackgroundBrush, null, rect); } Rect paddingRect = new Rect(this.Padding.Left, this.Padding.Top, Math.Max(0.0, base.ActualWidth - this.Padding.Left - this.Padding.Right), Math.Max(0.0, base.ActualHeight - this.Padding.Top - this.Padding.Bottom)); Point center = new Point((paddingRect.Left + paddingRect.Right) / 2.0, (paddingRect.Top + paddingRect.Bottom) / 2.0); Point startPosition; double paragraphWidth; if (textParagraphProperties.IsVerticalWriting) { Point origin = paddingRect.TopRight; Transform transOrigin = new RotateTransform(-90.0, center.X, center.Y); startPosition = transOrigin.Transform(origin); paragraphWidth = Math.Abs(paddingRect.Height); Transform trans = new RotateTransform(90.0, center.X, center.Y); drawingContext.PushTransform(trans); } else { startPosition = paddingRect.TopLeft; paragraphWidth = Math.Abs(paddingRect.Width); } startPosition.Y += textParagraphProperties.JapaneseTextRunProperties.FontRenderingEmSize; int textStorePosition = 0; Point linePosition = startPosition; TextFormatter formatter = TextFormatter.Create(); while (textStorePosition < source.Text.Length) { using (TextLine textLine = formatter.FormatLine(source, textStorePosition, paragraphWidth, textParagraphProperties, null)) { foreach (IndexedGlyphRun indexedrun in textLine.GetIndexedGlyphRuns()) { if (textParagraphProperties.IsVerticalWriting) { source.UniscribeIndexedGlyphRun(indexedrun); Rect runRect; if (source.GlyphCount != 0 && source.Glyphs[0] != 0) { Point ansiLinePosition = linePosition; ansiLinePosition.Y -= textParagraphProperties.JapaneseTextRunProperties.FontRenderingEmSize / 2.0; runRect = this.DrawIndexedGlyphRun(drawingContext, indexedrun, ansiLinePosition, source, true); } else { Point ansiLinePosition = linePosition; ansiLinePosition.Y -= textParagraphProperties.JapaneseTextRunProperties.FontRenderingEmSize / 10.0; runRect = this.DrawIndexedGlyphRun(drawingContext, indexedrun, ansiLinePosition, source, false); } linePosition.X += runRect.Width; } else { Rect runRect = this.DrawIndexedGlyphRun(drawingContext, indexedrun, linePosition, source, false); linePosition.X += runRect.Width; } } textStorePosition += textLine.Length; linePosition.X = startPosition.X; linePosition.Y += textLine.Height; } } if (textParagraphProperties.IsVerticalWriting) { drawingContext.Pop(); } }
private static Point DrawLineArrowInternal(DrawingContext dc, double half, Pen pen, Brush brush, double x, double y, double angle, ArrowStyle style) { Point pt; bool doRectTransform = angle % 90.0 != 0.0; var rt = new RotateTransform(angle, x, y); double rx = style.RadiusX; double ry = style.RadiusY; double sx = 2.0 * rx; double sy = 2.0 * ry; switch (style.ArrowType) { default: case ArrowType.None: { pt = new Point(x, y); } break; case ArrowType.Rectangle: { pt = rt.Transform(new Point(x - sx, y)); var rect = new Rect(x - sx, y - ry, sx, sy); if (doRectTransform) { dc.PushTransform(rt); DrawRectangleInternal(dc, half, brush, pen, style.IsStroked, style.IsFilled, ref rect); dc.Pop(); } else { var bounds = rt.TransformBounds(rect); DrawRectangleInternal(dc, half, brush, pen, style.IsStroked, style.IsFilled, ref bounds); } } break; case ArrowType.Ellipse: { pt = rt.Transform(new Point(x - sx, y)); dc.PushTransform(rt); var c = new Point(x - rx, y); DrawEllipseInternal(dc, half, brush, pen, style.IsStroked, style.IsFilled, ref c, rx, ry); dc.Pop(); } break; case ArrowType.Arrow: { pt = rt.Transform(new Point(x, y)); var p11 = rt.Transform(new Point(x - sx, y + sy)); var p21 = rt.Transform(new Point(x, y)); var p12 = rt.Transform(new Point(x - sx, y - sy)); var p22 = rt.Transform(new Point(x, y)); DrawLineInternal(dc, half, pen, style.IsStroked, ref p11, ref p21); DrawLineInternal(dc, half, pen, style.IsStroked, ref p12, ref p22); } break; } return pt; }
public bool RotatedRectContains(Rectangle rect, System.Windows.Point location) { var rectCorner = new System.Windows.Point(Canvas.GetLeft(rect), Canvas.GetTop(rect)); var rectRotation = (RotateTransform)rect.RenderTransform; var transform = new RotateTransform(-rectRotation.Angle, rectCorner.X + rectRotation.CenterX, rectCorner.Y + rectRotation.CenterY); var rotated = transform.Transform(location); return rotated.X > rectCorner.X && rotated.X < rectCorner.X + rect.Width && rotated.Y > rectCorner.Y && rotated.Y < rectCorner.Y + rect.Height; }
/// <summary> /// Intersects a line with a geometry to return the point of intersection /// </summary> /// <param name="node"></param> /// <param name="p"></param> /// <param name="centerVector"></param> /// <param name="t"></param> /// <returns></returns> private static Point FindOppositePoint(PathGeometry node, Point p, Vector centerVector, Transform t) { Vector xaxis = new Point(1, 0) - new Point(0, 0); double angleBetween = Vector.AngleBetween(centerVector, xaxis); RotateTransform r = new RotateTransform(angleBetween, p.X, p.Y); SortedList pointList = new SortedList(); for (int i = 0; i < node.Figures.Count; i++) { PathFigure pf = node.Figures[i]; Point lastPathFigurePoint = r.Transform(pf.StartPoint); for (int j = 0; j < pf.Segments.Count; j++) { if (pf.Segments[j] is PolyLineSegment) { PolyLineSegment pls = (PolyLineSegment)pf.Segments[j]; for (int k = 0; k < pls.Points.Count; k++) { Point point1 = r.Transform(pls.Points[k]); CheckLineSegmentForIntersection(p, point1, lastPathFigurePoint, pointList); lastPathFigurePoint = point1; } } else if (pf.Segments[j] is LineSegment) { LineSegment ls = (LineSegment)pf.Segments[j]; Point p1 = r.Transform(ls.Point); Point p2 = lastPathFigurePoint; lastPathFigurePoint = p1; CheckLineSegmentForIntersection(p, p1, p2, pointList); } } } if (pointList.Count < 1) { return centerVector + p; } Point returnPt = new Point((double)pointList.GetByIndex(0), p.Y); r.Angle = -1 * angleBetween; returnPt = r.Transform(returnPt); Vector finalVector = returnPt - p; if (finalVector.Length > centerVector.Length) { return centerVector + p; } return returnPt; }
private void ShowSortedItemsInGraph(List<ItemSize> SortedItemList) { bool hasBoundary = true; Brush boundaryBrush = Brushes.Black; double boundaryThickness = 0.5; Point pieCenter = new Point(PIE_RADIUS, PIE_RADIUS); Point startPoint = new Point(PIE_RADIUS, 0); //Set bitmap effect for the pie graph #pragma warning disable 0618 PieGraph.BitmapEffect = new BevelBitmapEffect(); #pragma warning restore 0618 //Move the center of the pie view to the origin of the canvas (canvas origin is located at the center of the view) ScaleTransform scale = new ScaleTransform(absScaleFactor, absScaleFactor); TransformGroup trasfm = new TransformGroup(); trasfm.Children.Add(new TranslateTransform(-PIE_RADIUS, -PIE_RADIUS)); trasfm.Children.Add(scale); PieGraph.RenderTransform = trasfm; for (int i = 0; i < SortedItemList.Count; i++) { var item = SortedItemList[i]; double angle = 360 * item.Percentage; if (angle >= 360) angle = 360 - 1e-5; RotateTransform rotate = new RotateTransform(angle, pieCenter.X, pieCenter.Y); Point endPoint = rotate.Transform(startPoint); //Draw a fan shape PathFigure fig = new PathFigure(); fig.StartPoint = pieCenter; fig.IsClosed = hasBoundary; fig.Segments.Add(new LineSegment(startPoint, hasBoundary)); fig.Segments.Add(new ArcSegment(endPoint, new Size(PIE_RADIUS, PIE_RADIUS), 0, angle > 180, SweepDirection.Clockwise, hasBoundary)); fig.Segments[0].IsSmoothJoin = fig.Segments[1].IsSmoothJoin = true; PathGeometry geo = new PathGeometry(); geo.Figures.Add(fig); //Set color and boundary line for current fan shape System.Windows.Shapes.Path fan = new System.Windows.Shapes.Path(); fan.Fill = PieColors[i % PieColors.Length]; fan.Stroke = boundaryBrush; fan.StrokeThickness = boundaryThickness; fan.Data = geo; //Add tooptip for current fan shape ToolTip tip = new ToolTip(); //A colored rectangle used as an icon of the tooltip Rectangle tipIcon = new Rectangle(); tipIcon.Width = tipIcon.Height = 40; tipIcon.Fill = fan.Fill; tipIcon.Margin = new Thickness(0, 0, 4, 0); //Tooltip message TextBox tipMsg = new TextBox(); string name = (item.IsFolder) ? "[" + item.Name + "]" : item.Name; tipMsg.Text = String.Format("{0}\n{1} Bytes\n{2}%", name, item.Size.ToString("n0"), (item.Percentage * 100).ToString("n2")); //Assembly tooltip icon and message into a panel and set it to the fan shape tooltip StackPanel tipPanel = new StackPanel(); tipPanel.Orientation = Orientation.Horizontal; tipPanel.Children.Add(tipIcon); tipPanel.Children.Add(tipMsg); tip.Content = tipPanel; fan.ToolTip = tip; //Add a trigger to current fan so that it is highlighted when mouse is over it Trigger trigger = new Trigger(); trigger.Property = System.Windows.Shapes.Path.IsMouseOverProperty; trigger.Value = true; trigger.Setters.Add(new Setter(System.Windows.Shapes.Path.OpacityProperty, 0.6)); Style style = new Style(); style.Triggers.Add(trigger); fan.Style = style; //Add current fan to the graph PieGraph.Children.Add(fan); startPoint = endPoint; } }
/// <summary> /// /// </summary> /// <param name="dc"></param> /// <param name="line"></param> /// <param name="dx"></param> /// <param name="dy"></param> /// <param name="db"></param> /// <param name="r"></param> public void Draw(object dc, XLine line, double dx, double dy, ImmutableArray<ShapeProperty> db, Record r) { var _dc = dc as DrawingContext; var style = line.Style; if (style == null) return; double zoom = _state.Zoom; double thicknessLine = style.Thickness / zoom; double halfLine = thicknessLine / 2.0; double thicknessStartArrow = style.StartArrowStyle.Thickness / zoom; double halfStartArrow = thicknessStartArrow / 2.0; double thicknessEndArrow = style.EndArrowStyle.Thickness / zoom; double halfEndArrow = thicknessEndArrow / 2.0; // line style Tuple<Brush, Pen> lineCache = null; Brush fillLine; Pen strokeLine; if (_enableStyleCache && _styleCache.TryGetValue(style, out lineCache)) { fillLine = lineCache.Item1; strokeLine = lineCache.Item2; } else { fillLine = CreateBrush(style.Fill); strokeLine = CreatePen(style, thicknessLine); if (_enableStyleCache) _styleCache.Add(style, Tuple.Create(fillLine, strokeLine)); } // start arrow style Tuple<Brush, Pen> startArrowCache = null; Brush fillStartArrow; Pen strokeStartArrow; if (_enableArrowStyleCache && _arrowStyleCache.TryGetValue(style.StartArrowStyle, out startArrowCache)) { fillStartArrow = startArrowCache.Item1; strokeStartArrow = startArrowCache.Item2; } else { fillStartArrow = CreateBrush(style.StartArrowStyle.Fill); strokeStartArrow = CreatePen(style.StartArrowStyle, thicknessStartArrow); if (_enableArrowStyleCache) _arrowStyleCache.Add(style.StartArrowStyle, Tuple.Create(fillStartArrow, strokeStartArrow)); } // end arrow style Tuple<Brush, Pen> endArrowCache = null; Brush fillEndArrow; Pen strokeEndArrow; if (_enableArrowStyleCache && _arrowStyleCache.TryGetValue(style.EndArrowStyle, out endArrowCache)) { fillEndArrow = endArrowCache.Item1; strokeEndArrow = endArrowCache.Item2; } else { fillEndArrow = CreateBrush(style.EndArrowStyle.Fill); strokeEndArrow = CreatePen(style.EndArrowStyle, thicknessEndArrow); if (_enableArrowStyleCache) _arrowStyleCache.Add(style.EndArrowStyle, Tuple.Create(fillEndArrow, strokeEndArrow)); } // line max length double x1 = line.Start.X + dx; double y1 = line.Start.Y + dy; double x2 = line.End.X + dx; double y2 = line.End.Y + dy; XLine.SetMaxLength(line, ref x1, ref y1, ref x2, ref y2); // arrow transforms var sas = style.StartArrowStyle; var eas = style.EndArrowStyle; double a1 = Math.Atan2(y1 - y2, x1 - x2) * 180.0 / Math.PI; double a2 = Math.Atan2(y2 - y1, x2 - x1) * 180.0 / Math.PI; bool doRectTransform1 = a1 % 90.0 != 0.0; bool doRectTransform2 = a2 % 90.0 != 0.0; var t1 = new RotateTransform(a1, x1, y1); var t2 = new RotateTransform(a2, x2, y2); Point pt1; Point pt2; // draw start arrow double radiusX1 = sas.RadiusX; double radiusY1 = sas.RadiusY; double sizeX1 = 2.0 * radiusX1; double sizeY1 = 2.0 * radiusY1; switch (sas.ArrowType) { default: case ArrowType.None: { pt1 = new Point(x1, y1); } break; case ArrowType.Rectangle: { pt1 = t1.Transform(new Point(x1 - sizeX1, y1)); var rect = new Rect(x1 - sizeX1, y1 - radiusY1, sizeX1, sizeY1); if (doRectTransform1) { _dc.PushTransform(t1); DrawRectangleInternal(_dc, halfStartArrow, fillStartArrow, strokeStartArrow, sas.IsStroked, sas.IsFilled, ref rect); _dc.Pop(); } else { var bounds = t1.TransformBounds(rect); DrawRectangleInternal(_dc, halfStartArrow, fillStartArrow, strokeStartArrow, sas.IsStroked, sas.IsFilled, ref bounds); } } break; case ArrowType.Ellipse: { pt1 = t1.Transform(new Point(x1 - sizeX1, y1)); _dc.PushTransform(t1); var c = new Point(x1 - radiusX1, y1); DrawEllipseInternal(_dc, halfStartArrow, fillStartArrow, strokeStartArrow, sas.IsStroked, sas.IsFilled, ref c, radiusX1, radiusY1); _dc.Pop(); } break; case ArrowType.Arrow: { pt1 = t1.Transform(new Point(x1, y1)); var p11 = t1.Transform(new Point(x1 - sizeX1, y1 + sizeY1)); var p21 = t1.Transform(new Point(x1, y1)); var p12 = t1.Transform(new Point(x1 - sizeX1, y1 - sizeY1)); var p22 = t1.Transform(new Point(x1, y1)); DrawLineInternal(_dc, halfStartArrow, strokeStartArrow, sas.IsStroked, ref p11, ref p21); DrawLineInternal(_dc, halfStartArrow, strokeStartArrow, sas.IsStroked, ref p12, ref p22); } break; } // draw end arrow double radiusX2 = eas.RadiusX; double radiusY2 = eas.RadiusY; double sizeX2 = 2.0 * radiusX2; double sizeY2 = 2.0 * radiusY2; switch (eas.ArrowType) { default: case ArrowType.None: { pt2 = new Point(x2, y2); } break; case ArrowType.Rectangle: { pt2 = t2.Transform(new Point(x2 - sizeX2, y2)); var rect = new Rect(x2 - sizeX2, y2 - radiusY2, sizeX2, sizeY2); if (doRectTransform2) { _dc.PushTransform(t2); DrawRectangleInternal(_dc, halfEndArrow, fillEndArrow, strokeEndArrow, eas.IsStroked, eas.IsFilled, ref rect); _dc.Pop(); } else { var bounds = t2.TransformBounds(rect); DrawRectangleInternal(_dc, halfEndArrow, fillEndArrow, strokeEndArrow, eas.IsStroked, eas.IsFilled, ref bounds); } } break; case ArrowType.Ellipse: { pt2 = t2.Transform(new Point(x2 - sizeX2, y2)); _dc.PushTransform(t2); var c = new Point(x2 - radiusX2, y2); DrawEllipseInternal(_dc, halfEndArrow, fillEndArrow, strokeEndArrow, eas.IsStroked, eas.IsFilled, ref c, radiusX2, radiusY2); _dc.Pop(); } break; case ArrowType.Arrow: { pt2 = t2.Transform(new Point(x2, y2)); var p11 = t2.Transform(new Point(x2 - sizeX2, y2 + sizeY2)); var p21 = t2.Transform(new Point(x2, y2)); var p12 = t2.Transform(new Point(x2 - sizeX2, y2 - sizeY2)); var p22 = t2.Transform(new Point(x2, y2)); DrawLineInternal(_dc, halfEndArrow, strokeEndArrow, eas.IsStroked, ref p11, ref p21); DrawLineInternal(_dc, halfEndArrow, strokeEndArrow, eas.IsStroked, ref p12, ref p22); } break; } // draw line using points from arrow transforms DrawLineInternal(_dc, halfLine, strokeLine, line.IsStroked, ref pt1, ref pt2); }
private static DrawingImage GetIcon_Equipment(Brush brushPrimary, Brush brushSecondary) { DrawingGroup group = new DrawingGroup(); GeometryDrawing drawing = null; #region circle drawing = new GeometryDrawing() { Pen = new Pen() { Thickness = 5, DashCap = PenLineCap.Flat, StartLineCap = PenLineCap.Flat, EndLineCap = PenLineCap.Flat, LineJoin = PenLineJoin.Miter, MiterLimit = 10, Brush = brushPrimary, }, Geometry = new EllipseGeometry() { Center = new Point(50, 50), RadiusX = 40, RadiusY = 40, }, }; group.Children.Add(drawing); #endregion #region center dot drawing = new GeometryDrawing() { Brush = brushPrimary, Geometry = new EllipseGeometry() { Center = new Point(50, 50), RadiusX = 4, RadiusY = 4, }, }; group.Children.Add(drawing); #endregion #region spokes Pen pen = new Pen() { Thickness = 10, DashCap = PenLineCap.Flat, StartLineCap = PenLineCap.Triangle, EndLineCap = PenLineCap.Round, LineJoin = PenLineJoin.Miter, MiterLimit = 10, Brush = brushSecondary, }; Point start = new Point(62.9735178272456, 42.420594688); Point end = new Point(73.7538857402056, 36.26268532736); RotateTransform rotate = new RotateTransform(0, 50, 50); for (int cntr = 0; cntr < 6; cntr++) { rotate.Angle = 60 * cntr; drawing = new GeometryDrawing() { Pen = pen, Geometry = new LineGeometry(rotate.Transform(start), rotate.Transform(end)), }; group.Children.Add(drawing); } #endregion DrawingImage retVal = new DrawingImage(); retVal.Drawing = group; return retVal; }
public static Geometry GetMarkerGeometry(MarkerType markerType, Point markerOrigin, Size markerSize, double startAngle = 0.0, double sweepAngle = 0.0) { switch (markerType) { case MarkerType.Circle: return (Geometry)new EllipseGeometry() { Center = new Point(markerSize.Width / 2.0 - markerOrigin.X, markerSize.Height / 2.0 - markerOrigin.Y), RadiusX = (markerSize.Width / 2.0), RadiusY = (markerSize.Height / 2.0) }; case MarkerType.Star4: case MarkerType.Star5: case MarkerType.Star10: PointCollection points1 = new PointCollection(); RotateTransform rotateTransform1 = new RotateTransform(); rotateTransform1.CenterX = markerSize.Width / 2.0; rotateTransform1.CenterY = markerSize.Height / 2.0; int num1 = 4; if (markerType == MarkerType.Star5) num1 = 5; else if (markerType == MarkerType.Star10) num1 = 10; for (int index = 0; index < num1 * 2; ++index) { Point point = new Point(markerSize.Width / 2.0, index % 2 == 0 ? 0.0 : markerSize.Height / 3.0); rotateTransform1.Angle = (double)index * 360.0 / ((double)num1 * 2.0); point = rotateTransform1.Transform(point); point.X -= markerOrigin.X; point.Y -= markerOrigin.Y; points1.Add(point); } return VisualUtilities.CreatePolyLineGeometry(points1); case MarkerType.Triangle: return VisualUtilities.CreatePolyLineGeometry(new PointCollection() { new Point(markerSize.Width / 2.0 - markerOrigin.X, 0.0 - markerOrigin.Y), new Point(markerSize.Width - markerOrigin.X, markerSize.Height - markerOrigin.Y), new Point(0.0 - markerOrigin.X, markerSize.Height - markerOrigin.Y) }); case MarkerType.Square: case MarkerType.Rectangle: return (Geometry)new RectangleGeometry() { Rect = new Rect(0.0 - markerOrigin.X, 0.0 - markerOrigin.Y, markerSize.Width, markerSize.Height) }; case MarkerType.Diamond: return VisualUtilities.CreatePolyLineGeometry(new PointCollection() { new Point(markerSize.Width / 2.0 - markerOrigin.X, 0.0 - markerOrigin.Y), new Point(markerSize.Width - markerOrigin.X, markerSize.Height / 2.0 - markerOrigin.Y), new Point(markerSize.Width / 2.0 - markerOrigin.X, markerSize.Height - markerOrigin.Y), new Point(0.0 - markerOrigin.X, markerSize.Height / 2.0 - markerOrigin.Y) }); case MarkerType.Cross: case MarkerType.CrossRotated: Size size1 = new Size(markerSize.Width / 4.0, markerSize.Height / 4.0); Point[] pointArray = new Point[12] { new Point(markerSize.Width / 2.0 - size1.Width / 2.0 - markerOrigin.X, 0.0 - markerOrigin.Y), new Point(markerSize.Width / 2.0 + size1.Width / 2.0 - markerOrigin.X, 0.0 - markerOrigin.Y), new Point(markerSize.Width / 2.0 + size1.Width / 2.0 - markerOrigin.X, markerSize.Height / 2.0 - size1.Height / 2.0 - markerOrigin.Y), new Point(markerSize.Width - markerOrigin.X, markerSize.Height / 2.0 - size1.Height / 2.0 - markerOrigin.Y), new Point(markerSize.Width - markerOrigin.X, markerSize.Height / 2.0 + size1.Height / 2.0 - markerOrigin.Y), new Point(markerSize.Width / 2.0 + size1.Width / 2.0 - markerOrigin.X, markerSize.Height / 2.0 + size1.Height / 2.0 - markerOrigin.Y), new Point(markerSize.Width / 2.0 + size1.Width / 2.0 - markerOrigin.X, markerSize.Height - markerOrigin.Y), new Point(markerSize.Width / 2.0 - size1.Width / 2.0 - markerOrigin.X, markerSize.Height - markerOrigin.Y), new Point(markerSize.Width / 2.0 - size1.Width / 2.0 - markerOrigin.X, markerSize.Height / 2.0 + size1.Height / 2.0 - markerOrigin.Y), new Point(0.0 - markerOrigin.X, markerSize.Height / 2.0 + size1.Height / 2.0 - markerOrigin.Y), new Point(0.0 - markerOrigin.X, markerSize.Height / 2.0 - size1.Height / 2.0 - markerOrigin.Y), new Point(markerSize.Width / 2.0 - size1.Width / 2.0 - markerOrigin.X, markerSize.Height / 2.0 - size1.Height / 2.0 - markerOrigin.Y) }; PointCollection points2 = new PointCollection(); if (markerType == MarkerType.CrossRotated) { RotateTransform rotateTransform2 = new RotateTransform(); rotateTransform2.Angle = 45.0; rotateTransform2.CenterX = markerSize.Width / 2.0 - markerOrigin.X; rotateTransform2.CenterY = markerSize.Height / 2.0 - markerOrigin.Y; for (int index = 0; index < pointArray.Length; ++index) points2.Add(rotateTransform2.Transform(pointArray[index])); } else { for (int index = 0; index < pointArray.Length; ++index) points2.Add(pointArray[index]); } return VisualUtilities.CreatePolyLineGeometry(points2); case MarkerType.Trapezoid: Size size2 = new Size(markerSize.Width / 3.0, markerSize.Height / 3.0); return VisualUtilities.CreatePolyLineGeometry(new PointCollection() { new Point(size2.Width - markerOrigin.X, 0.0 - markerOrigin.Y), new Point(markerSize.Width - size2.Width - markerOrigin.X, 0.0 - markerOrigin.Y), new Point(markerSize.Width - markerOrigin.X, markerSize.Height - markerOrigin.Y), new Point(0.0 - markerOrigin.X, markerSize.Height - markerOrigin.Y) }); case MarkerType.Pentagon: PointCollection points3 = new PointCollection(); RotateTransform rotateTransform3 = new RotateTransform(); rotateTransform3.CenterX = markerSize.Width / 2.0 - markerOrigin.X; rotateTransform3.CenterY = markerSize.Height / 2.0 - markerOrigin.Y; int num2 = 5; for (int index = 0; index < num2; ++index) { Point point = new Point(markerSize.Width / 2.0 - markerOrigin.X, 0.0 - markerOrigin.Y); rotateTransform3.Angle = (double)index * 360.0 / (double)num2; point = rotateTransform3.Transform(point); points3.Add(point); } return VisualUtilities.CreatePolyLineGeometry(points3); case MarkerType.Wedge: Size size3 = new Size(markerSize.Width / 3.0, markerSize.Height / 3.0); return VisualUtilities.CreatePolyLineGeometry(new PointCollection() { new Point(markerSize.Width / 2.0 - markerOrigin.X, 0.0 - markerOrigin.Y), new Point(markerSize.Width - markerOrigin.X, size3.Height - markerOrigin.Y), new Point(markerSize.Width - markerOrigin.X, markerSize.Height - markerOrigin.Y), new Point(0.0 - markerOrigin.X, markerSize.Height - markerOrigin.Y), new Point(0.0 - markerOrigin.X, size3.Height - markerOrigin.Y) }); case MarkerType.PieSlice: if (sweepAngle >= 360.0) return (Geometry)new EllipseGeometry() { Center = new Point(markerSize.Width / 2.0 - markerOrigin.X, markerSize.Height / 2.0 - markerOrigin.Y), RadiusX = (markerSize.Width / 2.0), RadiusY = (markerSize.Height / 2.0) }; Point point1 = new Point(markerSize.Width / 2.0 - markerOrigin.X, markerSize.Height / 2.0 - markerOrigin.Y); Point point2 = new Point(point1.X, point1.Y - markerSize.Height / 2.0); Point point3 = VisualUtilities.RotatePointBy(point2, startAngle); Point point4 = VisualUtilities.RotatePointBy(point2, startAngle + sweepAngle); PathFigure pathFigure = new PathFigure() { StartPoint = VisualUtilities.ShiftPoint(point1) }; pathFigure.Segments.Add((PathSegment)new LineSegment() { Point = VisualUtilities.ShiftPoint(point3) }); pathFigure.Segments.Add((PathSegment)new ArcSegment() { IsLargeArc = (sweepAngle >= 180.0), SweepDirection = SweepDirection.Clockwise, Size = new Size(markerSize.Width / 2.0, markerSize.Height / 2.0), Point = VisualUtilities.ShiftPoint(point4) }); pathFigure.Segments.Add((PathSegment)new LineSegment() { Point = VisualUtilities.ShiftPoint(point1) }); return (Geometry)new PathGeometry() { Figures = { pathFigure } }; default: return (Geometry)null; } }
private void DrawCar(Map map) { if (lastCar != null) Canvas_trackPlanner.Children.Remove(lastCar); const double CAR_WIDTH = 55; const double CAR_HEIGHT = 25; const double FRONT_SHOWER_LENTH = 10; System.Windows.Shapes.Polyline car = new Polyline(); car.StrokeThickness = 7; car.Stroke = new SolidColorBrush(Colors.Red); car.Points = new PointCollection() { new Point(map.car.x + CAR_WIDTH / 2, map.car.y + CAR_HEIGHT / 2), new Point(map.car.x - CAR_WIDTH / 2, map.car.y + CAR_HEIGHT / 2), new Point(map.car.x - CAR_WIDTH / 2, map.car.y - CAR_HEIGHT / 2), new Point(map.car.x + CAR_WIDTH / 2, map.car.y - CAR_HEIGHT / 2), new Point(map.car.x + CAR_WIDTH / 2, map.car.y), new Point(map.car.x + CAR_WIDTH + FRONT_SHOWER_LENTH / 2, map.car.y), new Point(map.car.x + CAR_WIDTH / 2, map.car.y), new Point(map.car.x + CAR_WIDTH / 2, map.car.y + CAR_HEIGHT / 2)}; RotateTransform rt = new RotateTransform(map.car.angle, map.car.x, map.car.y); car.Points = new PointCollection(car.Points.Select(x => rt.Transform(x))); Canvas_trackPlanner.Children.Add(car); lastCar = car; }
public XYLabelsPanel.LabelMeasureResult Measure(double angle, bool staggered, bool tryLabelWrap, double gap) { double offset = 0.0; double marginLeft = 0.0; double marginRight = 0.0; bool hasCollisions = false; bool flag = false; double availableLenght = this.Parent.AvailableSizeInMeasureCycle.Width; if (staggered) { List<AxisLabelControl> firstLevel = new List<AxisLabelControl>(); List<AxisLabelControl> secondLevel = new List<AxisLabelControl>(); EnumerableFunctions.ForEachWithIndex<AxisLabelControl>((IEnumerable<AxisLabelControl>)this.Elements, (Action<AxisLabelControl, int>)((label, index) => { if (index % 2 > 0) secondLevel.Add(label); else firstLevel.Add(label); })); XYLabelsPanel.LabelMeasureInfo labelMeasureInfo1 = new XYLabelsPanel.LabelMeasureInfo(this.Parent, this.Level, (IList<AxisLabelControl>)firstLevel); XYLabelsPanel.LabelMeasureInfo labelMeasureInfo2 = new XYLabelsPanel.LabelMeasureInfo(this.Parent, this.Level, (IList<AxisLabelControl>)secondLevel); XYLabelsPanel.LabelMeasureResult firstInfo = labelMeasureInfo1.Measure(0.0, false, false, gap * 2.0); XYLabelsPanel.LabelMeasureResult labelMeasureResult = labelMeasureInfo2.Measure(0.0, false, false, gap * 2.0); secondLevel.ForEach((Action<AxisLabelControl>)(label => XYLabelsPanel.SetLevelOffset((UIElement)label, firstInfo.Offset))); offset = firstInfo.Offset + labelMeasureResult.Offset; marginLeft = Math.Max(firstInfo.MarginLeft, labelMeasureResult.MarginLeft); marginRight = Math.Max(firstInfo.MarginRight, labelMeasureResult.MarginRight); hasCollisions = firstInfo.HasCollisions || labelMeasureResult.HasCollisions || firstInfo.StaggeredCollisions || labelMeasureResult.StaggeredCollisions || marginRight + marginLeft > availableLenght * 0.35; angle = 0.0; } else { if (angle == 0.0 && tryLabelWrap) this.EvaluateWrapFlag(); this.PrepareLabels(angle); if (this.ClientRectangles.Count > 0) { offset = Enumerable.Max(Enumerable.Select<Rect, double>((IEnumerable<Rect>)this.ClientRectangles, (Func<Rect, double>)(r => r.Height))); List<Rect> list1 = this.AdjustRectanglesToAvailableLength(this.ClientRectangles, this.AngleOffsets, availableLenght, gap); if (!this.Parent.Presenter.IsScaleZoomed) { list1.ForEach((Action<Rect>)(r => { marginLeft = Math.Max(Math.Max(0.0, marginLeft), -r.Left); marginRight = Math.Max(Math.Max(0.0, marginRight), r.Right - availableLenght); })); marginLeft = Math.Ceiling(double.IsNaN(marginLeft) ? 0.0 : marginLeft); marginRight = Math.Ceiling(double.IsNaN(marginRight) ? 0.0 : marginRight); } else if (!(this.Parent.Axis.Scale is CategoryScale)) { list1.ForEach((Action<Rect>)(r => marginLeft = Math.Max(Math.Max(0.0, marginLeft), r.Width / 2.0))); marginLeft = Math.Ceiling(double.IsNaN(marginLeft) ? 0.0 : marginLeft); marginRight = marginLeft; } double availableLenght1 = Math.Max(0.0, availableLenght - (marginRight + marginLeft)); List<Rect> list2; if (!DoubleHelper.EqualsWithPrecision(Math.Abs(angle % 90.0), 0.0)) { List<Rect> list3 = this.AdjustRectanglesToAvailableLength(this.ContentRectangles, (IList<Point>)null, availableLenght1, gap); RotateTransform transform = new RotateTransform() { Angle = angle }; list2 = Enumerable.ToList<Rect>(Enumerable.Select<Rect, Rect>((IEnumerable<Rect>)list3, (Func<Rect, Rect>)(r => { Point point = transform.Transform(new Point(r.X + r.Width / 2.0, r.Y + r.Height / 2.0)); return new Rect(point.X, point.Y, r.Width, r.Height); }))); } else list2 = this.AdjustRectanglesToAvailableLength(this.ClientRectangles, this.AngleOffsets, availableLenght1, gap); hasCollisions = this.TextWrapFlagResult != TextWrapping.Wrap && this.HasCollisions((IList<Rect>)list2, angle != 0.0); if (!DoubleHelper.EqualsWithPrecision(Math.Abs(angle % 90.0), 0.0)) hasCollisions = hasCollisions || marginRight + marginLeft > availableLenght * 0.35; flag = hasCollisions || angle != 0.0; if (!flag && list2.Count > 1) { double distance = Enumerable.Min(Enumerable.Zip<Rect, Rect, double>((IEnumerable<Rect>)list2, Enumerable.Skip<Rect>((IEnumerable<Rect>)list2, 1), (Func<Rect, Rect, double>)((prev, next) => Math.Abs(next.X + next.Width / 2.0 - (prev.X + prev.Width / 2.0))))); flag = Enumerable.Any<Rect>((IEnumerable<Rect>)list2, (Func<Rect, bool>)(r => r.Width > distance)); } } } return new XYLabelsPanel.LabelMeasureResult(offset, marginLeft, marginRight, hasCollisions, angle, staggered) { StaggeredCollisions = flag }; }