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);
}
}
