public Point PointRelativeToOrigin(Geometry.Shapes.Point point) { m_Converter.GeometryPoint = point; m_Converter.Convert(); return m_Converter.Point; }
internal CameraPicture() { _geometry = new CombinedGeometry() { Geometry1 = new RectangleGeometry(new Rect(0, 3, 14, 8), 1, 1), Geometry2 = new PathGeometry() { Figures = new PathFigureCollection() { new PathFigure() { StartPoint = new Point(16,5), IsClosed = false, Segments = new PathSegmentCollection() { new LineSegment(new Point(20,2),true), new LineSegment(new Point(20,12),true), new LineSegment(new Point(16,9),true), } } } } }; _geometry.Freeze(); _brushes = new Dictionary<Brush, Brush>(); }
public static Sm.Drawing ToGeometryDrawing(this Shape input) { Sm.GeometryDrawing geometryDrawing = new Sm.GeometryDrawing(); Sm.GeometryGroup drawing = new Sm.GeometryGroup(); if (input.IsCompound) { foreach (Geometry geo in input.Geometries) { Sm.Geometry geometry = geo.ToGeometry(); drawing.Children.Add(geometry); } } else { Sm.Geometry geometry = input.ToGeometry(); drawing.Children.Add(geometry); } geometryDrawing.Geometry = drawing; geometryDrawing.Pen = input.Graphic.Stroke.ToMediaPen(); geometryDrawing.Brush = input.Graphic.Fill.ToMediaBrush(); Sm.DrawingGroup drawingGroup = new Sm.DrawingGroup(); drawingGroup.Children.Add(geometryDrawing); return(drawingGroup); }
public static Sm.DrawingVisual ToVisualDrawing(this Shape input) { Sm.DrawingVisual drawingVisual = new Sm.DrawingVisual(); Sm.DrawingContext drawingContext = drawingVisual.RenderOpen(); Sm.GeometryGroup drawing = new Sm.GeometryGroup(); if (input.IsCompound) { foreach (Geometry geo in input.Geometries) { Sm.Geometry geometry = geo.ToGeometry(); drawing.Children.Add(geometry); } } else { Sm.Geometry geometry = input.ToGeometry(); drawing.Children.Add(geometry); } drawingContext.DrawGeometry(input.Graphic.Fill.ToMediaBrush(), input.Graphic.Stroke.ToMediaPen(), drawing); drawingContext.Close(); if (input.Graphic.Effects.HasBlurEffect) { drawingVisual.Effect = input.Graphic.Effects.Blur.ToMediaEffect(); } if (input.Graphic.Effects.HasShadowEffect) { drawingVisual.Effect = input.Graphic.Effects.Shadow.ToMediaEffect(); } return(drawingVisual); }
public static void AdjustPathForAnimations(PathElement pathElement, SceneEditTransaction editTransaction) { using (pathElement.ViewModel.ForceBaseValue()) { System.Windows.Media.Geometry geometry1 = (System.Windows.Media.Geometry)pathElement.GetLocalOrDefaultValueAsWpf(PathElement.DataProperty); PathGeometry pathGeometry = new PathGeometry(); pathGeometry.AddGeometry(geometry1); Rect bounds = PathCommandHelper.InflateRectByStrokeWidth(pathGeometry.Bounds, pathElement, false); PropertyReference propertyReference = PathCommandHelper.GetPathDataPropertyReference(pathElement.Platform); Rect maxAnimatedExtent = PathCommandHelper.FindMaxAnimatedExtent((SceneElement)pathElement, bounds, propertyReference); double num1 = Math.Min(0.0, maxAnimatedExtent.Left); double num2 = Math.Min(0.0, maxAnimatedExtent.Top); Vector vector = new Vector(-num1, -num2); ILayoutDesigner designerForChild = pathElement.ViewModel.GetLayoutDesignerForChild((SceneElement)pathElement, true); editTransaction.Update(); Rect childRect = designerForChild.GetChildRect((BaseFrameworkElement)pathElement); childRect.X += num1; childRect.Y += num2; childRect.Width = Math.Max(maxAnimatedExtent.Width, childRect.Width); childRect.Height = Math.Max(maxAnimatedExtent.Height, childRect.Height); designerForChild.SetChildRect((BaseFrameworkElement)pathElement, childRect); Transform transform = (Transform) new TranslateTransform(vector.X, vector.Y); PathGeometry geometry2 = PathGeometryUtilities.TransformGeometry((System.Windows.Media.Geometry)pathGeometry, transform); if (!pathElement.DesignerContext.ActiveDocument.ProjectContext.IsCapabilitySet(PlatformCapability.IsWpf)) { PathGeometryUtilities.EnsureOnlySingleSegmentsInGeometry(geometry2); } pathElement.PathGeometry = geometry2; PathCommandHelper.TransformPointKeyframes((SceneElement)pathElement, propertyReference, transform); pathElement.SetValueAsWpf(ShapeElement.StretchProperty, (object)(Stretch)(pathElement.HasVertexAnimations ? 0 : 1)); } }
private RectangleHitTestResultTreeNode HitTestGeometry(System.Windows.Media.Geometry geometry) { RectangleGeometry rectangleGeometry = geometry as RectangleGeometry; Rect rect = rectangleGeometry != null ? rectangleGeometry.Rect : geometry.GetFlattenedPathGeometry().Bounds; RectangleHitTestResultTreeNode parent = new RectangleHitTestResultTreeNode((RectangleHitTestResultTreeNode)null, (DependencyObject)null); for (int index = 0; index < this.viewports.Count; ++index) { List <Point> frustumOutline = new List <Point>(); Point point1 = this.viewports[index].Transform.Transform(rect.TopLeft); Point point2 = this.viewports[index].Transform.Transform(rect.TopRight); Point point3 = this.viewports[index].Transform.Transform(rect.BottomRight); Point point4 = this.viewports[index].Transform.Transform(rect.BottomLeft); frustumOutline.Add(point1); frustumOutline.Add(point2); frustumOutline.Add(point3); frustumOutline.Add(point4); this.frustum = this.BuildFrustumFromViewport(this.viewports[index], frustumOutline); RectangleHitTestResultTreeNode testResultTreeNode = new RectangleHitTestResultTreeNode(parent, (DependencyObject)null); if (this.WalkVisual3DChildren(this.viewports[index].Children, Matrix3D.Identity, testResultTreeNode)) { parent.AddChild(testResultTreeNode); } } return(parent); }
protected override void Initialize(System.Windows.Media.Geometry primaryGeometry) { this.fragments = new List <System.Windows.Media.Geometry>(1); this.fragments.Add(primaryGeometry); this.mostRecentGeometry = primaryGeometry; this.unionOfPreviousGeometries = (System.Windows.Media.Geometry)null; }
public override void Draw(DrawingContext context, Matrix matrix) { if (!this.ShouldDraw) { return; } bool flag = this.AdornerSet.Behavior.Tool is BrushTransformTool; Matrix matrix1 = this.GetCompleteBrushTransformMatrix(true) * matrix; if (flag) { Rect brushBounds = this.BrushBounds; if (brushBounds.Width <= 0.0 || brushBounds.Height <= 0.0) { return; } Pen thinPen = this.ThinPen; System.Windows.Media.Geometry rectangleGeometry = Adorner.GetTransformedRectangleGeometry(brushBounds, matrix1, thinPen.Thickness); context.DrawGeometry((Brush)Brushes.Transparent, thinPen, rectangleGeometry); } else { Pen pen = new Pen((Brush)Brushes.Transparent, 15.0); pen.Freeze(); if (!PlatformTypes.IsInstance(this.PlatformBrush, PlatformTypes.GradientBrush, (ITypeResolver)this.Element.ProjectContext)) { return; } Point startPoint; Point endPoint; this.GetBrushOffsetEndpoints(out startPoint, out endPoint, 13.0, 11.0, matrix); context.DrawLine(pen, startPoint, endPoint); context.DrawLine(this.ThinPen, startPoint, endPoint); } }
public static Telerik.Windows.Documents.Fixed.Model.Graphics.GeometryBase ConvertGeometry(Geometry geometry) { #if SILVERLIGHT var cloner = new Telerik.Windows.Controls.GeometryCloneConverter(); geometry = (Geometry)cloner.Convert(geometry, null, null, null); #endif PathGeometry pathGeometry = geometry as PathGeometry; if (pathGeometry != null) { return ConvertPathGeometry(pathGeometry); } RectangleGeometry rectangleGeometry = geometry as RectangleGeometry; if (rectangleGeometry != null) { return ConvertRectangleGeometry(rectangleGeometry); } EllipseGeometry ellipseGeometry = geometry as EllipseGeometry; if (ellipseGeometry != null) { return ConvertEllipseGeometry(ellipseGeometry); } #if WPF StreamGeometry streamGeometry = geometry as StreamGeometry; if (streamGeometry != null) { return ConvertStreamGeometry(streamGeometry); } #endif return null; }
protected void UpdateProvisionalContainerHighlight() { if (this.ProvisionalContainer == null) { this.FeedbackAdorner.CloseAdorner(); } else { SceneView activeView = this.ActiveView; BaseFrameworkElement frameworkElement = this.provisionalContainer; this.FeedbackAdorner.Text = string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.ProvisionalDragDropText, new object[1] { (object)frameworkElement.DisplayNameNoTextContent }); DrawingContext context = this.OpenFeedback(); Rect computedTightBounds = frameworkElement.GetComputedTightBounds(); System.Windows.Media.Geometry rectangleGeometry = Adorner.GetTransformedRectangleGeometry(activeView, (SceneElement)frameworkElement, computedTightBounds, 0.0, false); this.DashPen.Thickness = 1.5 / activeView.Zoom; this.WhitePen.Thickness = 1.5 / activeView.Zoom; context.DrawGeometry((Brush)null, this.WhitePen, rectangleGeometry); context.DrawGeometry((Brush)null, this.DashPen, rectangleGeometry); this.FeedbackAdorner.DrawAdorner(context); this.CloseFeedback(); } }
/// <summary> /// Create the outline geometry based on the formatted text. /// </summary> public void CreateText() { FontStyle fontStyle = FontStyles.Normal; FontWeight fontWeight = FontWeights.Medium; if (Bold == true) fontWeight = FontWeights.Bold; if (Italic == true) fontStyle = FontStyles.Italic; // Create the formatted text based on the properties set. FormattedText formattedText = new FormattedText( Text, CultureInfo.GetCultureInfo("en-us"), FlowDirection.LeftToRight, new Typeface(Font, fontStyle, fontWeight, FontStretches.Normal), FontSize, Brushes.Black // This brush does not matter since we use the geometry of the text. ); // Build the geometry object that represents the text. _textGeometry = formattedText.BuildGeometry(new Point(0, 0)); //set the size of the custome control based on the size of the text this.MinWidth = formattedText.Width; this.MinHeight = formattedText.Height; }
private UIElement GetPositionedCodeTag(ITextViewLine line, IWpfTextViewLineCollection textViewLines, Geometry geometry) { int lineNumber = _view.TextSnapshot.GetLineNumberFromPosition(line.Start.Position) + 1; UIElement codeTagElement = CodeLine.ElementAt(lineNumber, GetFilename); PlaceVisualNextToGeometry(geometry, codeTagElement); return codeTagElement; }
///<summary> /// Converts a flat path to a <see cref="IGeometry"/>. ///</summary> /// <param name="pathIt">The path iterator of the path to convert</param> /// <returns>A Geometry representing the path</returns> public IGeometry Read(WpfGeometry pathIt) { var pathPtSeq = ToCoordinates(pathIt); var polys = new List <IGeometry>(); var seqIndex = 0; while (seqIndex < pathPtSeq.Count) { // assume next seq is shell // TODO: test this var pts = pathPtSeq[seqIndex]; var shell = _geometryFactory.CreateLinearRing(pts); seqIndex++; var holes = new List <ILinearRing>(); Coordinate[] holePts; // add holes as long as rings are CCW while (seqIndex < pathPtSeq.Count && IsHole(holePts = pathPtSeq[seqIndex])) { var hole = _geometryFactory.CreateLinearRing(holePts); holes.Add(hole); seqIndex++; } var holeArray = holes.ToArray();//GeometryFactory.ToLinearRingArray(holes); polys.Add(_geometryFactory.CreatePolygon(shell, holeArray)); } return(_geometryFactory.BuildGeometry(polys)); }
/// <summary> /// Calculates the score from the shape the players have to fill and their overall shadow. /// </summary> /// <param name="shapeToFill">The shape players have to fill.</param> /// <param name="peoplesShadows">The players' overall shadow.</param> /// <returns>The players' score.</returns> public int ScoreFromGeometries(Geometry shapeToFill, Geometry peoplesShadows) { double fillScore = Geometry.Combine(shapeToFill, peoplesShadows, GeometryCombineMode.Intersect, null).GetArea(); double penalties = Geometry.Combine(peoplesShadows, shapeToFill, GeometryCombineMode.Exclude, null).GetArea(); double score = fillScore * 15 - (penalties / 50); return score > 0 ? (int)score : 0; }
/// <summary> /// Constructor. /// </summary> /// <param name="pieceNumber">Which piece number this piece contains.</param> /// <param name="pieceShape">The shape of the pieces.</param> /// <param name="brush">The image and viewbox to use as this piece's visual.</param> public PuzzlePiece(int pieceNumber, Geometry pieceShape, VisualBrush brush) { clipShape = pieceShape; imageBrush = brush; pieces = new HashSet<int>(); pieces.Add(pieceNumber); }
public static PathGeometry RemoveDegeneratePoints(System.Windows.Media.Geometry geometry) { if (geometry == null) { return((PathGeometry)null); } PathGeometry pathGeometry1 = new PathGeometry(); pathGeometry1.AddGeometry(geometry); PathGeometry pathGeometry2 = geometry as PathGeometry; if (pathGeometry2 != null) { pathGeometry1.FillRule = pathGeometry2.FillRule; } for (int index = 0; index < pathGeometry1.Figures.Count; ++index) { PathFigure pathFigure = pathGeometry1.Figures[index]; if (pathFigure.IsFrozen) { pathFigure = pathFigure.Clone(); pathGeometry1.Figures[index] = pathFigure; } PathConversionHelper.ReplacePolySegments(pathFigure.Segments); bool removeInvisible = true; PathConversionHelper.RemoveDegenerateSegments(pathFigure, removeInvisible); if (pathFigure.Segments.Count == 0) { pathGeometry1.Figures.RemoveAt(index--); } } return(pathGeometry1); }
/// <summary> /// Creates a very long line at the bottom of bounds. /// </summary> public override GraphicsResult GetGraphics(IWpfTextView view, Geometry bounds) { Initialize(view); var border = new Border() { BorderBrush = _graphicsTagBrush, BorderThickness = new Thickness(0, 0, 0, bottom: 1), Height = 1, Width = view.ViewportWidth }; EventHandler viewportWidthChangedHandler = (s, e) => { border.Width = view.ViewportWidth; }; view.ViewportWidthChanged += viewportWidthChangedHandler; // Subtract rect.Height to ensure that the line separator is drawn // at the bottom of the line, rather than immediately below. // This makes the line separator line up with the outlining bracket. Canvas.SetTop(border, bounds.Bounds.Bottom - border.Height); return new GraphicsResult(border, () => view.ViewportWidthChanged -= viewportWidthChangedHandler); }
protected override void Combine(System.Windows.Media.Geometry secondaryGeometry) { this.unionOfPreviousGeometries = this.unionOfPreviousGeometries != null ? (System.Windows.Media.Geometry)System.Windows.Media.Geometry.Combine(this.unionOfPreviousGeometries, this.mostRecentGeometry, GeometryCombineMode.Union, (Transform)null) : this.mostRecentGeometry; this.mostRecentGeometry = secondaryGeometry; List <System.Windows.Media.Geometry> list = new List <System.Windows.Media.Geometry>(2 * this.fragments.Count + 1); foreach (System.Windows.Media.Geometry geometry1 in this.fragments) { System.Windows.Media.Geometry geometry2 = (System.Windows.Media.Geometry)System.Windows.Media.Geometry.Combine(geometry1, secondaryGeometry, GeometryCombineMode.Exclude, (Transform)null); System.Windows.Media.Geometry geometry3 = (System.Windows.Media.Geometry)System.Windows.Media.Geometry.Combine(geometry1, secondaryGeometry, GeometryCombineMode.Intersect, (Transform)null); if (!geometry2.Bounds.IsEmpty) { list.Add(geometry2); } if (!geometry3.Bounds.IsEmpty) { list.Add(geometry3); } } System.Windows.Media.Geometry geometry = (System.Windows.Media.Geometry)System.Windows.Media.Geometry.Combine(secondaryGeometry, this.unionOfPreviousGeometries, GeometryCombineMode.Exclude, (Transform)null); if (!geometry.Bounds.IsEmpty) { list.Add(geometry); } this.fragments = list; }
private static Drawing SimplifyGeometryDrawing(GeometryDrawing geometryDrawing) { bool flag = geometryDrawing.Pen == null || geometryDrawing.Pen.Thickness == 0.0; if (geometryDrawing.Geometry == null || geometryDrawing.Geometry.IsEmpty() || geometryDrawing.Brush == null && flag) { return((Drawing)null); } System.Windows.Media.Geometry geometry = geometryDrawing.Geometry; if (geometry is StreamGeometry && geometry.Transform != null && !geometry.Transform.Value.IsIdentity) { PathGeometry pathGeometry = new PathGeometry(); pathGeometry.AddGeometry(geometry); geometryDrawing.Geometry = (System.Windows.Media.Geometry)pathGeometry; } if (geometryDrawing.Brush == null) { geometryDrawing.ClearValue(GeometryDrawing.BrushProperty); } if (flag) { geometryDrawing.ClearValue(GeometryDrawing.PenProperty); } return((Drawing)geometryDrawing); }
///<summary> /// Converts a flat path to a <see cref="IGeometry"/>. ///</summary> /// <param name="pathIt">The path iterator of the path to convert</param> /// <returns>A Geometry representing the path</returns> public IGeometry Read(WpfGeometry pathIt) { var pathPtSeq = ToCoordinates(pathIt); var polys = new List<IGeometry>(); var seqIndex = 0; while (seqIndex < pathPtSeq.Count) { // assume next seq is shell // TODO: test this var pts = pathPtSeq[seqIndex]; var shell = _geometryFactory.CreateLinearRing(pts); seqIndex++; var holes = new List<ILinearRing>(); Coordinate[] holePts; // add holes as long as rings are CCW while (seqIndex < pathPtSeq.Count && IsHole(holePts = pathPtSeq[seqIndex])) { var hole = _geometryFactory.CreateLinearRing(holePts); holes.Add(hole); seqIndex++; } var holeArray = holes.ToArray();//GeometryFactory.ToLinearRingArray(holes); polys.Add(_geometryFactory.CreatePolygon(shell, holeArray)); } return _geometryFactory.BuildGeometry(polys); }
void UpdateMarkersVisual(Geometry geometry) { DrawingContext context = markers.RenderOpen(); context.DrawRectangle(Brushes.Red, new Pen(Brushes.Red, 1), new Rect(30, 30, 30, 30)); context.Close(); }
//public void DrawEllipse(Brush brush, Pen pen, Point center, AnimationClock centerAnimations, double radiusX, AnimationClock radiusXAnimations, double radiusY, AnimationClock radiusYAnimations); public void DrawGeometry(Brush brush, Pen pen, Geometry geometry) { Path path = new Path(); SetupShape(path, 0, 0, Double.NaN, Double.NaN, brush, pen); path.Data = geometry; ActiveCanvas.Children.Add(path); }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { INode listBoxNode = value as INode; if (listBoxNode != null) { graphControl.Graph.Clear(); var size = FlowChartNodeStyle.GetNodeTypeSize(listBoxNode); var node = graphControl.Graph.CreateNode(new RectD(0, 0, size.Width, size.Height), listBoxNode.Style, listBoxNode.Tag); double labelHeight = 0; foreach (var label in listBoxNode.Labels) { graphControl.Graph.AddLabel(node, label.Text, label.LayoutParameter, label.Style, label.PreferredSize, label.Tag); labelHeight = Math.Max(labelHeight, label.GetLayout().Height); } graphControl.FitGraphBounds(new InsetsD(5)); ContextConfigurator cc = new ContextConfigurator(graphControl.ContentRect); var renderContext = cc.CreateRenderContext(graphControl); Transform transform = cc.CreateWorldToIntermediateTransform(); System.Windows.Media.Geometry clip = cc.CreateClip(); var visualContent = graphControl.ExportContent(renderContext); VisualGroup container = new VisualGroup() { Transform = transform, Clip = clip, Children = { visualContent } }; VisualBrush brush = new VisualBrush(container); return(new DrawingImage(new GeometryDrawing(brush, null, new RectangleGeometry(new Rect(0, 0, size.Width, size.Height + labelHeight))))); } else { return(null); } }
protected override void EndEditingInternal(bool pathJustCreated) { PathGeometry pathGeometry1 = PathGeometryUtilities.Copy(this.PathGeometry, false); bool isAnimated = this.IsAnimated; if (!isAnimated && this.ViewModel.AnimationEditor.IsKeyFraming) { System.Windows.Media.Geometry geometry1 = (System.Windows.Media.Geometry) this.editingElement.GetComputedValueAsWpf(Base2DElement.ClipProperty); PathGeometry geometry2 = new PathGeometry(); if (geometry1 != null) { geometry2.AddGeometry(geometry1); } PathGeometryUtilities.EnsureOnlySingleSegmentsInGeometry(geometry2); SceneNode sceneNode = this.editingElement.ViewModel.CreateSceneNode(this.editingElement.ViewModel.DefaultView.ConvertFromWpfValue((object)geometry2)); sceneNode.SetLocalValueAsWpf(DesignTimeProperties.IsAnimatedProperty, (object)true); this.editingElement.SetValueAsSceneNode(Base2DElement.ClipProperty, sceneNode); this.editingElement.ViewModel.Document.OnUpdatedEditTransaction(); } if (this.EditingElement.IsAttached && (this.ViewModel.AnimationEditor.IsKeyFraming || isAnimated)) { new PathDiff(this.EditingElement, Base2DElement.ClipProperty, this.PathDiffChangeList).SetPathUsingMinimalDiff(pathGeometry1); } else { PathGeometry pathGeometry2 = PathGeometryUtilities.RemoveMapping(pathGeometry1, true); this.EditingElement.SetValueAsWpf(Base2DElement.ClipProperty, (object)pathGeometry2); } }
/// <summary> /// DrawGeometry - /// Draw a Geometry with the provided Brush and/or Pen. /// If both the Brush and Pen are null this call is a no-op. /// </summary> /// <param name="brush"> /// The Brush with which to fill the Geometry. /// This is optional, and can be null, in which case no fill is performed. /// </param> /// <param name="pen"> /// The Pen with which to stroke the Geometry. /// This is optional, and can be null, in which case no stroke is performed. /// </param> /// <param name="geometry"> The Geometry to fill and/or stroke. </param> public override void DrawGeometry( Brush brush, Pen pen, Geometry geometry) { if (IsCurrentLayerNoOp ||(geometry == null) || geometry.IsEmpty()) { return; } if (brush != null) { _contains |= geometry.FillContains(_point); } // If we have a pen and we haven't yet hit, try the widened geometry. if ((pen != null) && !_contains) { _contains |= geometry.StrokeContains(pen, _point); } // If we've hit, stop walking. if (_contains) { StopWalking(); } }
protected override Size MeasureOverride(Size constraint) { var midX = X1 + ((X2 - X1) / 2); _geometry = new PathGeometry { Figures = { new PathFigure { IsFilled = false, StartPoint = new Point(X1, Y1), Segments = { new BezierSegment { Point1 = new Point(midX, Y1), Point2 = new Point(midX, Y2), Point3 = new Point(X2, Y2), IsStroked = true } } } } }; return base.MeasureOverride(constraint); }
public override GraphicsResult GetGraphics(IWpfTextView view, Geometry geometry) { Initialize(view); // We clip off a bit off the start of the line to prevent a half-square being // drawn. var clipRectangle = geometry.Bounds; clipRectangle.Offset(2, 0); var line = new Line { X1 = geometry.Bounds.Left, Y1 = geometry.Bounds.Bottom - _graphicsTagPen.Thickness, X2 = geometry.Bounds.Right, Y2 = geometry.Bounds.Bottom - _graphicsTagPen.Thickness, Clip = new RectangleGeometry { Rect = clipRectangle } }; // RenderOptions.SetEdgeMode(line, EdgeMode.Aliased); ApplyPen(line, _graphicsTagPen); // Shift the line over to offset the clipping we did. line.RenderTransform = new TranslateTransform(-_graphicsTagPen.Thickness, 0); return new GraphicsResult(line, null); }
private void AddLabel(Point position, string title, int power) { drawing.Children.Clear(); TranslateTransform trans = new TranslateTransform(position.X, position.Y); if (bottom) { TransformGroup tr = new TransformGroup(); tr.Children.Add(trans); tr.Children.Add(new RotateTransform(90, position.X, position.Y)); } if (Math.Abs(power) >= 3) { const int powerFont = 8; geoAxis = MakeText(title + " ×10", new Point(0, bottom ? 5 : 10)); scientificNotation = MakeText(power + "", new Point(geoAxis.Bounds.Right + (powerFont), geoAxis.Bounds.Top - (powerFont / 3.0)), powerFont); group = new GeometryGroup(); group.Children.Add(geoAxis); group.Children.Add(scientificNotation); } else { geoAxis = MakeText(title, new Point(0, bottom ? 5 : 10)); group = new GeometryGroup(); group.Children.Add(geoAxis); } drawing.Children.Add(new GeometryDrawing(null, new Pen(Brushes.Black, 2), line)); drawing.Children.Add(new GeometryDrawing(Brushes.Black, null, group)); drawing.Children.Add(axisLabels); }
public Pen GetPen(Geometry geometry) { double strokeWidth = GetStrokeWidth(); if (strokeWidth == 0) return null; WpfSvgPaint stroke; if (PaintType == SvgPaintType.None) { return null; } else if (PaintType == SvgPaintType.CurrentColor) { stroke = new WpfSvgPaint(_context, _element, "color"); } else { stroke = this; } Pen pen = new Pen(stroke.GetBrush(geometry, "stroke", true), strokeWidth); pen.StartLineCap = pen.EndLineCap = GetLineCap(); pen.LineJoin = GetLineJoin(); double miterLimit = GetMiterLimit(strokeWidth); if (miterLimit > 0) { pen.MiterLimit = miterLimit; } //pen.MiterLimit = 1.0f; DoubleCollection dashArray = GetDashArray(strokeWidth); if (dashArray != null && dashArray.Count != 0) { bool isValidDashes = true; //Do not draw if dash array had a zero value in it for (int i = 0; i < dashArray.Count; i++) { if (dashArray[i] == 0) { isValidDashes = false; } } if (isValidDashes) { DashStyle dashStyle = new DashStyle(dashArray, GetDashOffset(strokeWidth)); pen.DashStyle = dashStyle; // This is the one that works well for the XAML, the default is not Flat as // stated in the documentations... pen.DashCap = PenLineCap.Flat; } } return pen; }
public PostInfoDisplay(double textRightEdge, double viewRightEdge, Geometry newTextGeometry, string body) { if (brush == null) { brush = new SolidColorBrush(Color.FromArgb(0x20, 0x48, 0x3d, 0x8b)); brush.Freeze(); Brush penBrush = new SolidColorBrush(Colors.DarkSlateBlue); penBrush.Freeze(); solidPen = new Pen(penBrush, 0.5); solidPen.Freeze(); dashPen = new Pen(penBrush, 0.5); dashPen.DashStyle = DashStyles.Dash; dashPen.Freeze(); } this.textGeometry = newTextGeometry; TextBlock tb = new TextBlock(); tb.Text = "Blog Entry: " + body; const int MarginWidth = 8; this.postGrid = new Grid(); this.postGrid.RowDefinitions.Add(new RowDefinition()); this.postGrid.RowDefinitions.Add(new RowDefinition()); ColumnDefinition cEdge = new ColumnDefinition(); cEdge.Width = new GridLength(MarginWidth); ColumnDefinition cEdge2 = new ColumnDefinition(); cEdge2.Width = new GridLength(MarginWidth); this.postGrid.ColumnDefinitions.Add(cEdge); this.postGrid.ColumnDefinitions.Add(new ColumnDefinition()); this.postGrid.ColumnDefinitions.Add(cEdge2); System.Windows.Shapes.Rectangle rect = new System.Windows.Shapes.Rectangle(); rect.RadiusX = 6; rect.RadiusY = 3; rect.Fill = brush; rect.Stroke = Brushes.DarkSlateBlue; Size inf = new Size(double.PositiveInfinity, double.PositiveInfinity); tb.Measure(inf); this.postGrid.Width = tb.DesiredSize.Width + 2 * MarginWidth; Grid.SetColumn(rect, 0); Grid.SetRow(rect, 0); Grid.SetRowSpan(rect, 1); Grid.SetColumnSpan(rect, 3); Grid.SetRow(tb, 0); Grid.SetColumn(tb, 1); this.postGrid.Children.Add(rect); this.postGrid.Children.Add(tb); Canvas.SetLeft(this.postGrid, Math.Max(viewRightEdge - this.postGrid.Width - 20.0, textRightEdge + 20.0)); Canvas.SetTop(this.postGrid, textGeometry.GetRenderBounds(solidPen).Top); this.Children.Add(this.postGrid); }
public void Draw(Geometry.Collection geometry) { _graphics.Clear(); DrawGrid(); DrawPictures(geometry.Polylines); DrawPoints(geometry.Points); DrawMousePos(); }
/// <summary> /// Calculates the percentage of the shape the players have to fill that is filled by their shadow. /// </summary> /// <param name="shapeToFill">The shape players have to fill.</param> /// <param name="peoplesShadows">The players' overall shadow.</param> /// <returns>The percentage of the shape that is filled by the players' overall shadow.</returns> public float FilledPercentageFromGeometries(Geometry shapeToFill, Geometry peoplesShadows) { double maximumArea = shapeToFill.GetArea(); double filledArea = Geometry.Combine(shapeToFill, peoplesShadows, GeometryCombineMode.Intersect, null).GetArea(); double percentage = 100 * filledArea / maximumArea; percentage = Math.Round(percentage*1.5, 2); return percentage > 100 ? 100 : (float)percentage; }
protected override PathGeometry GetResult() { PathGeometry pathGeometry = this.resultGeometry; this.primaryGeometry = (System.Windows.Media.Geometry)null; this.resultGeometry = (PathGeometry)null; return(pathGeometry); }
public List<DrawingVisual> GetVisuals(Geometry region) { hits.Clear(); GeometryHitTestParameters parameters = new GeometryHitTestParameters(region); HitTestResultCallback callback = new HitTestResultCallback(this.HitTestCallback); VisualTreeHelper.HitTest(this, null, callback, parameters); return hits; }
protected virtual void OnApplyChildClip() { var child = Child; if (child == null) return; // Get the geometry of a rounded rectangle border based on the BorderThickness and CornerRadius _clipRect = GeometryHelper.GetRoundRectangle(new Rect(Child.RenderSize), BorderThickness, CornerRadius); child.Clip = _clipRect; }
/// <summary> /// Constructor from 2 operands /// </summary> /// <param name="geometry1"> /// First geometry to combine /// </param> /// <param name="geometry2"> /// Second geometry to combine /// </param> public CombinedGeometry( Geometry geometry1, Geometry geometry2 ) { Geometry1 = geometry1; Geometry2 = geometry2; }
private void UpdatePath() { double offset = 7 * Math.Log(Max / Value, 2) / Math.Log(Max / Min, 2); double size = offset < 4 ? 4 : 8 - offset; if (double.IsNaN(offset) || double.IsNaN(size) || double.IsInfinity(offset) || double.IsInfinity(size)) return; PathData = Geometry.Parse(string.Format("M {0} {1} L 8 {2} L {3} {1} M {0} {4} L 8 {5} L {3} {4}", 8 - size, offset + size, offset, 8 + size, 16 - size - offset, 16 - offset)); }
private System.Windows.Media.Geometry ApplyCurrentClippingToGeometry(System.Windows.Media.Geometry targetGeometry, SceneElement clippedElement) { System.Windows.Media.Geometry geometry1 = (System.Windows.Media.Geometry)(clippedElement.GetComputedValueAsWpf(Base2DElement.ClipProperty) as PathGeometry); if (geometry1 != null && !geometry1.IsEmpty()) { targetGeometry = (System.Windows.Media.Geometry)System.Windows.Media.Geometry.Combine(geometry1, targetGeometry, GeometryCombineMode.Intersect, (Transform)null); } return(targetGeometry); }
public HandUserGameObject(double xPosition, double yPosition, Geometry boundingBoxGeometry, Image notAlreadyTrackedImage, Image image, SkeletonSmoothingFilter skeletonSmoothingFilter) : base(xPosition, yPosition, boundingBoxGeometry, notAlreadyTrackedImage, image, skeletonSmoothingFilter) { }
public IList<object> GetItemsInGeometry(Geometry geometry) { if (geometry == null || geometry.IsEmpty()) { return null; } return Items.Cast<object>().Where(i => IsItemInGeometry(i, geometry)).ToList(); }
public List <DrawingVisual> GetVisuals(System.Windows.Media.Geometry region) { hits.Clear(); GeometryHitTestParameters parameters = new GeometryHitTestParameters(region); HitTestResultCallback callback = HitTestCallback; VisualTreeHelper.HitTest(this, null, callback, parameters); return(hits); }
public object GetFirstItemInGeometry(Geometry geometry) { if (geometry == null || geometry.IsEmpty()) { return null; } return Items.Cast<object>().FirstOrDefault(i => IsItemInGeometry(i, geometry)); }
private void DefineGeometry() { PointCollection points = Points; if (points == null) { _geometry = Geometry.Empty; return; } PathFigure figure = new PathFigure(); if (points.Count > 0) { // start point figure.StartPoint = points[0]; if (points.Count > 1) { // points between double desiredRadius = Radius; for (int i = 1; i < (points.Count - 1); i++) { // adjust radius if points are too close Vector v1 = points[i] - points[i - 1]; Vector v2 = points[i + 1] - points[i]; double radius = Math.Min(Math.Min(v1.Length, v2.Length) / 2, desiredRadius); // draw the line, and stop before the next point double len = v1.Length; v1.Normalize(); v1 *= (len - radius); LineSegment line = new LineSegment(points[i - 1] + v1, true); figure.Segments.Add(line); // draw the arc to the next point v2.Normalize(); v2 *= radius; SweepDirection direction = (Vector.AngleBetween(v1, v2) > 0) ? SweepDirection.Clockwise : SweepDirection.Counterclockwise; ArcSegment arc = new ArcSegment(points[i] + v2, new Size(radius, radius), 0, false, direction, true); figure.Segments.Add(arc); } // last point figure.Segments.Add(new LineSegment(points[points.Count - 1], true)); } } PathGeometry geometry = new PathGeometry(); geometry.Figures.Add(figure); geometry.FillRule = FillRule; if (geometry.Bounds == Rect.Empty) { _geometry = Geometry.Empty; } else { _geometry = geometry; } }
public static void DrawGeometry(StreamGeometryContext ctx, System.Windows.Media.Geometry geo) { var pathGeometry = geo as PathGeometry ?? PathGeometry.CreateFromGeometry(geo); foreach (var figure in pathGeometry.Figures) { DrawFigure(ctx, figure); } }
public void Update(System.Windows.Media.Geometry symbol, List <Point> pointCollection, bool canEdit = true, bool polyBezierMode = true) { this._symbol = symbol; this.Extent = BoundingBox.CalculateBoundingBox(pointCollection); _pointCollection = pointCollection; this._isPolyBezierMode = polyBezierMode; }
/// <summary> /// Constructor from combine mode and 2 operands /// </summary> /// <param name="geometryCombineMode"> /// Combine mode - Union, Intersect, Exclude or Xor /// </param> /// <param name="geometry1"> /// First geometry to combine /// </param> /// <param name="geometry2"> /// Second geometry to combine /// </param> public CombinedGeometry( GeometryCombineMode geometryCombineMode, Geometry geometry1, Geometry geometry2 ) { GeometryCombineMode = geometryCombineMode; Geometry1 = geometry1; Geometry2 = geometry2; }
/// <summary> /// This method creates the text geometry. /// </summary> private void CreateTextGeometry() { var formattedText = new FormattedText(Text, Thread.CurrentThread.CurrentUICulture, FlowDirection.LeftToRight, new Typeface(FontFamily, FontStyle, FontWeight, FontStretch), FontSize, Brushes.Black); _textGeometry = formattedText.BuildGeometry(Origin); }
protected virtual void OnApplyChildClip() { UIElement child = this.Child; if (child != null) { // Get the geometry of a rounded rectangle border based on the BorderThickness and CornerRadius clipRect = GeometryHelper.GetRoundRectangle(new Rect(Child.RenderSize), this.BorderThickness, this.CornerRadius); child.Clip = clipRect; } }
public override void MouseMove(Canvas canvas, Point point) { EndPoint = point; _uiElement.Width = GeometryHelper.GetWidth(StartPosition, EndPoint); _uiElement.RenderTransform = new RotateTransform(GeometryHelper.GetAngle(StartPosition, EndPoint)); _geometry = null; _uiElement.Fill = IsValid() ? Brushes.Black : Brushes.Red; }
public void SimplifyPathData(ref System.Windows.Media.Geometry geometry) { PathGeometry geometry1 = geometry as PathGeometry; BooleanCommand.CleanUpPathGeometry(ref geometry1); PathGeometry geometry2 = PathConversionHelper.RemoveDegeneratePoints((System.Windows.Media.Geometry)geometry1); PathGeometryUtilities.CollapseSingleSegmentsToPolySegments(geometry2); PathCommandHelper.GrokPathPointPrecision(geometry2, 3); geometry = (System.Windows.Media.Geometry)geometry2; }
static PathButton() { // Set the style key, so that our control template is used. DefaultStyleKeyProperty.OverrideMetadata(typeof(PathButton), new FrameworkPropertyMetadata(typeof(PathButton))); Path path = new Path(); string sData = "M 250,40 L200,20 L200,60 Z"; var converter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(System.Windows.Media.Geometry)); pathData = (System.Windows.Media.Geometry)converter.ConvertFrom(sData); }
public static PathGeometry TransformGeometry(System.Windows.Media.Geometry geometry, Transform transform) { PathGeometry pathGeometry1 = new PathGeometry(); pathGeometry1.AddGeometry(geometry); pathGeometry1.Transform = transform; PathGeometry pathGeometry2 = new PathGeometry(); pathGeometry2.AddGeometry((System.Windows.Media.Geometry)pathGeometry1); return(pathGeometry2); }
/// <summary> /// Draw the freeform selection shape. /// </summary> /// <param name="dc"></param> protected virtual void DrawSelectionShape(DrawingContext dc) { if (_mgr != null) { // Draw the freeform selection System.Windows.Media.Geometry shapeGeo = _mgr.GetCaptureShape(); System.Windows.Media.Brush brush = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Colors.Yellow); System.Windows.Media.Pen pen = new System.Windows.Media.Pen(brush, 5.0); pen.DashStyle = System.Windows.Media.DashStyles.Dash; dc.DrawGeometry(brush, pen, shapeGeo); } }
/// <summary> /// Creates a new <see cref="PolygonMaskShapeView"/> element. /// </summary> public PolygonMaskShapeView() { _polygonGeometry = null; _polygonGeometryPathFigure = null; _polygonGeometryPolyLineSegment = null; SetBinding(PointsProperty, new Binding(nameof(ViewModel.Points)) { Mode = BindingMode.OneWay }); }
/// <summary> /// Returns the pure PathGeometry to easily display at the screen. /// </summary> /// <returns></returns> public static m.PathGeometry GeometryToPathGeometry(m.Geometry toConvert, double resolution = 20, bool wannaFlat = false) { m.PathGeometry myPathGeometry = toConvert.GetOutlinedPathGeometry(resolution, m.ToleranceType.Relative); if (wannaFlat) { myPathGeometry = myPathGeometry.GetFlattenedPathGeometry(resolution, m.ToleranceType.Relative); } return(myPathGeometry); }
static LayoutAdorner() { StreamGeometry streamGeometry = new StreamGeometry(); StreamGeometryContext streamGeometryContext = streamGeometry.Open(); streamGeometryContext.BeginFigure(new Point(0.0, 4.5), true, true); streamGeometryContext.LineTo(new Point(3.0, -3.0), true, false); streamGeometryContext.LineTo(new Point(-3.0, -3.0), true, false); streamGeometryContext.Close(); LayoutAdorner.TriangleGeometry = (System.Windows.Media.Geometry)streamGeometry; LayoutAdorner.TriangleGeometry.Freeze(); }
public void SetClip(System.Windows.Media.Geometry geometry) { if (_rectangle != null) { _rectangle.Clip = geometry; } if (_ellipse != null) { _ellipse.Clip = geometry; } }
protected override PathGeometry GetResult() { PathGeometry pathGeometry = new PathGeometry(); foreach (System.Windows.Media.Geometry geometry in this.fragments) { pathGeometry.AddGeometry(geometry); } this.fragments = (List <System.Windows.Media.Geometry>)null; this.mostRecentGeometry = (System.Windows.Media.Geometry)null; this.unionOfPreviousGeometries = (System.Windows.Media.Geometry)null; return(pathGeometry); }
/// <summary> /// In case of PolyBezierMode, control points must be included /// </summary> /// <param name="pointCollection"></param> /// <param name="extent"></param> /// <param name="polyBezierMode"></param> public SpecialLineLayer(System.Windows.Media.Geometry symbol, VisualParameters parameters, List <Point> pointCollection, bool canEdit = true, bool polyBezierMode = true) { if (!polyBezierMode) { throw new NotImplementedException(); } this.VisualParameters = parameters ?? VisualParameters.CreateNew(1); this.ZIndex = int.MaxValue; Update(symbol, pointCollection, canEdit, polyBezierMode); }
private bool TryParseGeometry(string value, out WGeometry geometry) { geometry = null; try { geometry = WGeometry.Parse(value); return(true); } catch (Exception) { return(false); } }