public static void DrawDimension(DrawingContext drawingContext, ElementLayoutAdornerType edge, Matrix matrix, Matrix rootMatrix, Pen pen, Rect bounds, double scale)
{
Point point1;
Point point2;
switch (edge)
{
case ElementLayoutAdornerType.Left:
point1 = bounds.TopLeft;
point2 = bounds.BottomLeft;
break;
case ElementLayoutAdornerType.Top:
point1 = bounds.TopLeft;
point2 = bounds.TopRight;
break;
case ElementLayoutAdornerType.Right:
point1 = bounds.TopRight;
point2 = bounds.BottomRight;
break;
case ElementLayoutAdornerType.Bottom:
point1 = bounds.BottomLeft;
point2 = bounds.BottomRight;
break;
default:
throw new NotSupportedException();
}
double length = ((point2 - point1) * rootMatrix).Length;
Point point3 = bounds.TopLeft + 0.5 * (bounds.BottomRight - bounds.TopLeft);
Point point4 = point1 * matrix;
Point point5 = point2 * matrix;
Point point6 = point3 * matrix;
Vector vector1 = point4 + 0.5 * (point5 - point4) - point6;
vector1.Normalize();
Vector vector2 = point5 - point4;
vector2.Normalize();
Vector overflowDirection = new Vector(vector2.Y, -vector2.X);
if (overflowDirection * vector1 < 0.0)
{
overflowDirection = -overflowDirection;
}
Point point7 = point4 - 0.5 * pen.Thickness * vector2;
Point point8 = point5 + 0.5 * pen.Thickness * vector2;
Vector vector3 = scale * 7.0 * overflowDirection;
Vector vector4 = scale * 22.0 * overflowDirection;
drawingContext.DrawLine(pen, point7 + vector3, point7 + vector4);
drawingContext.DrawLine(pen, point8 + vector3, point8 + vector4);
Point a = point4 + scale * 17.5 * overflowDirection;
Point b = point5 + scale * 17.5 * overflowDirection;
string text = length.ToString("0.###", (IFormatProvider)CultureInfo.CurrentCulture);
SizeAdorner.DrawLineAndText(drawingContext, a, b, overflowDirection, pen, pen.Brush, text, scale);
}
private void DrawAnimate(DrawingContext ctx, Matrix matrix, IEnumerable <IAdornerAnimation> activeAdornerAnimations)
{
IAdornerAnimation adornerAnimation = activeAdornerAnimations != null?Enumerable.FirstOrDefault <IAdornerAnimation>(activeAdornerAnimations, (Func <IAdornerAnimation, bool>)(item => item.Name == "PreviewBox")) : (IAdornerAnimation)null;
if (!this.ShouldDraw || this.Element.Visual == null)
{
return;
}
Rect elementBounds = this.ElementBounds;
Pen pen = this.BorderPen;
if (pen.IsFrozen && adornerAnimation != null)
{
pen = adornerAnimation.ClientData as Pen;
if (pen == null)
{
pen = this.BorderPen.Clone();
adornerAnimation.ClientData = (object)pen;
}
}
if (adornerAnimation != null)
{
pen.Brush.Opacity = adornerAnimation.LerpValue;
}
this.DrawBounds(ctx, elementBounds, (Brush)null, pen);
if (!this.AdornerSet.ToolContext.Tool.ShowDimensions || !this.Element.ViewModel.ElementSelectionSet.Selection.Contains(this.Element) || this.ElementSet.IsPrimaryTransformNonAffine)
{
return;
}
Matrix computedTransformToRoot = this.DesignerContext.ActiveView.GetComputedTransformToRoot(this.Element);
SizeAdorner.DrawDimension(ctx, ElementLayoutAdornerType.Right, matrix, computedTransformToRoot, pen, elementBounds, 1.0);
SizeAdorner.DrawDimension(ctx, ElementLayoutAdornerType.Bottom, matrix, computedTransformToRoot, pen, elementBounds, 1.0);
}
public override void Draw(DrawingContext ctx, Matrix matrix)
{
if (!this.shouldDraw)
{
return;
}
bool flag = this.AdornerSet is RectangleGeometryAdornerSetBase;
Point anchorPoint = this.GetAnchorPoint(matrix);
Brush brush = this.IsActive ? (flag ? FeedbackHelper.GetActiveBrush(AdornerType.ClipPath) : this.ActiveBrush) : this.InactiveBrush;
Pen pen = flag ? FeedbackHelper.GetThinPen(AdornerType.ClipPath) : this.ThinPen;
Rect targetRect = this.TargetRect;
AdornerRenderLocation location = AdornerRenderLocation.Outside;
if (this.DesignerContext.SelectionManager.ElementSelectionSet != null && this.DesignerContext.SelectionManager.ElementSelectionSet.Selection.Count > 1 && !this.ElementSet.AdornsMultipleElements)
{
location = AdornerRenderLocation.Inside;
}
SizeAdorner.DrawSizeAdorner(ctx, anchorPoint, this.EdgeFlags, matrix, brush, pen, targetRect, location);
if (!this.IsActive)
{
return;
}
Matrix transformMatrix = this.ElementSet.GetTransformMatrix(this.DesignerContext.ActiveView.ViewRoot);
SizeAdorner.DrawDimensions(ctx, matrix, transformMatrix, pen, targetRect, this.EdgeFlags);
}
public override void Draw(DrawingContext ctx, Matrix matrix)
{
Point anchorPoint = this.GetAnchorPoint(matrix);
Brush brush = this.IsActive ? this.ActiveBrush : this.InactiveBrush;
Rect elementBounds = this.ElementBounds;
if (this.Type == DesignTimeAdornerType.Width || this.Type == DesignTimeAdornerType.Height)
{
if (!this.handlingDrag || this.IsActive || !this.IsEnabled)
{
Pen thinPen = this.ThinPen;
this.DrawEdgeAdorner(ctx, anchorPoint, matrix, brush, thinPen, elementBounds);
}
}
else
{
if (!this.TestFlags(EdgeFlags.BottomRight))
{
throw new NotSupportedException();
}
Pen pen = this.IsEnabled ? this.MediumPen : this.ThinPen;
this.DrawCornerAdorner(ctx, anchorPoint, matrix, brush, pen);
}
if (!this.IsActive || !this.IsEnabled)
{
return;
}
Matrix transformMatrix = this.ElementSet.GetTransformMatrix(this.DesignerContext.ActiveView.ViewRoot);
SizeAdorner.DrawDimensions(ctx, matrix, transformMatrix, this.ThinPen, elementBounds, this.EdgeFlags);
}
public override void Draw(DrawingContext ctx, Matrix matrix)
{
if (this.Element.ParentElement == null || this.Element.Visual == null)
{
return;
}
Point pointBegin;
Point pointEnd;
this.GetPoints(out pointBegin, out pointEnd);
string text = string.Empty;
if (!this.IsAuto)
{
Matrix computedTransformToRoot = this.DesignerContext.ActiveView.GetComputedTransformToRoot((SceneElement)this.Element);
text = ((pointEnd - pointBegin) * computedTransformToRoot).Length.ToString("0.###", (IFormatProvider)CultureInfo.CurrentCulture);
}
Point a = pointBegin * matrix;
Point b = pointEnd * matrix;
Pen pen1 = this.ThinPen.Clone();
pen1.Brush.Opacity = 0.5;
if (this.IsAuto && VectorUtilities.SquaredDistance(a, b) < 10000000000.0)
{
pen1.DashStyle = ElementLayoutLineAdorner.LineDashStyle;
}
pen1.Freeze();
Vector overflowDirection = b - a;
overflowDirection.Normalize();
SizeAdorner.DrawLineAndText(ctx, a, b, overflowDirection, pen1, this.ActiveBrush, text, 1.0);
if (this.type != ElementLayoutAdornerType.Left)
{
return;
}
Transform transform1 = (Transform)this.Element.GetComputedValueAsWpf(Base2DElement.RenderTransformProperty);
Transform transform2 = (Transform)null;
IPropertyId propertyKey = (IPropertyId)this.Element.ProjectContext.ResolveProperty(BaseFrameworkElement.LayoutTransformProperty);
if (propertyKey != null)
{
transform2 = (Transform)this.Element.GetComputedValueAsWpf(propertyKey);
}
if ((transform1 == null || transform1.Value.IsIdentity) && (transform2 == null || transform2.Value.IsIdentity))
{
return;
}
RectangleGeometry rectangleGeometry = new RectangleGeometry(this.DesignerContext.ActiveSceneViewModel.GetLayoutDesignerForChild((SceneElement)this.Element, true).GetChildRect(this.Element), 0.0, 0.0, (Transform) new MatrixTransform(this.Element.GetComputedTransformFromVisualParent() * matrix));
rectangleGeometry.Freeze();
Pen pen2 = this.ThinPen.Clone();
pen2.Brush.Opacity = 0.5;
pen2.Freeze();
ctx.DrawGeometry((Brush)null, pen2, (System.Windows.Media.Geometry)rectangleGeometry);
}
public override void Draw(DrawingContext ctx, Matrix matrix)
{
if (!this.ShouldDraw)
{
return;
}
Point anchorPoint = this.GetAnchorPoint(matrix);
matrix = this.GetCompleteBrushTransformMatrix(true) * matrix;
Brush brush = this.IsActive ? this.ActiveBrush : this.InactiveBrush;
SizeAdorner.DrawSizeAdorner(ctx, anchorPoint, this.EdgeFlags, matrix, brush, this.ThinPen, this.BrushBounds, AdornerRenderLocation.Outside);
}
public static void DrawDimensions(DrawingContext drawingContext, Matrix matrix, Matrix rootMatrix, Pen pen, Rect bounds, EdgeFlags edgeFlags)
{
if ((edgeFlags & EdgeFlags.LeftOrRight) != EdgeFlags.None)
{
ElementLayoutAdornerType edge = (edgeFlags & EdgeFlags.Top) != EdgeFlags.None ? ElementLayoutAdornerType.Top : ElementLayoutAdornerType.Bottom;
SizeAdorner.DrawDimension(drawingContext, edge, matrix, rootMatrix, pen, bounds, 1.0);
}
if ((edgeFlags & EdgeFlags.TopOrBottom) == EdgeFlags.None)
{
return;
}
ElementLayoutAdornerType edge1 = (edgeFlags & EdgeFlags.Left) != EdgeFlags.None ? ElementLayoutAdornerType.Left : ElementLayoutAdornerType.Right;
SizeAdorner.DrawDimension(drawingContext, edge1, matrix, rootMatrix, pen, bounds, 1.0);
}
public static void DrawSizeAdorner(DrawingContext drawingContext, Point anchorPoint, EdgeFlags edgeFlags, Matrix matrix, Brush brush, Pen pen, Rect bounds, AdornerRenderLocation location)
{
if (SizeAdorner.SkipAdorner(edgeFlags, matrix, bounds))
{
return;
}
Vector vector1 = new Vector(1.0, 0.0) * matrix;
Vector vector2 = new Vector(0.0, 1.0) * matrix;
vector1.Normalize();
vector2.Normalize();
double num1 = matrix.Determinant < 0.0 ? -1.0 : 1.0;
Point point = anchorPoint;
Matrix matrix1 = new Matrix(0.0, 1.0 * num1, -1.0 * num1, 0.0, 0.0, 0.0);
Matrix matrix2 = new Matrix(0.0, -1.0 * num1, 1.0 * num1, 0.0, 0.0, 0.0);
Vector vector3 = vector1 * matrix1;
Vector vector4 = vector2 * matrix2;
Vector vector5 = vector1 * 8.0;
Vector vector6 = vector2 * 8.0;
if (location == AdornerRenderLocation.Inside)
{
switch (edgeFlags & EdgeFlags.TopOrBottom)
{
case EdgeFlags.None:
vector1 = vector4;
anchorPoint -= 0.5 * (5.0 - pen.Thickness) * vector2;
point += vector2 * 0.5 * 8.0;
break;
case EdgeFlags.Top:
vector2 = vector3;
anchorPoint += 0.5 * pen.Thickness * vector2;
point += vector2 * 8.0;
break;
case EdgeFlags.Bottom:
vector2 = vector3;
anchorPoint -= (5.0 - 0.5 * pen.Thickness) * vector2;
break;
}
switch (edgeFlags & EdgeFlags.LeftOrRight)
{
case EdgeFlags.None:
anchorPoint -= 0.5 * (5.0 - pen.Thickness) * vector1;
point += vector1 * 0.5 * 8.0;
break;
case EdgeFlags.Left:
anchorPoint += 0.5 * pen.Thickness * vector1;
point += vector1 * 8.0;
break;
case EdgeFlags.Right:
anchorPoint -= (5.0 - 0.5 * pen.Thickness) * vector1;
break;
}
}
else
{
switch (edgeFlags & EdgeFlags.TopOrBottom)
{
case EdgeFlags.None:
vector1 = vector4;
anchorPoint -= 0.5 * (5.0 - pen.Thickness) * vector2;
point += vector2 * 0.5 * 8.0;
break;
case EdgeFlags.Top:
vector2 = vector3;
anchorPoint -= (5.0 - 0.5 * pen.Thickness) * vector2;
break;
case EdgeFlags.Bottom:
vector2 = vector3;
anchorPoint += 0.5 * pen.Thickness * vector2;
point += vector2 * 8.0;
break;
}
switch (edgeFlags & EdgeFlags.LeftOrRight)
{
case EdgeFlags.None:
anchorPoint -= 0.5 * (5.0 - pen.Thickness) * vector1;
point += vector1 * 0.5 * 8.0;
break;
case EdgeFlags.Left:
anchorPoint -= (5.0 - 0.5 * pen.Thickness) * vector1;
break;
case EdgeFlags.Right:
anchorPoint += 0.5 * pen.Thickness * vector1;
point += vector1 * 8.0;
break;
}
}
StreamGeometry streamGeometry1 = new StreamGeometry();
StreamGeometryContext streamGeometryContext1 = streamGeometry1.Open();
streamGeometryContext1.BeginFigure(point - vector5, true, true);
streamGeometryContext1.LineTo(point - vector5 - vector6, false, false);
streamGeometryContext1.LineTo(point - vector6, false, false);
streamGeometryContext1.LineTo(point, false, false);
streamGeometryContext1.Close();
streamGeometry1.Freeze();
drawingContext.DrawGeometry((Brush)Brushes.Transparent, (Pen)null, (System.Windows.Media.Geometry)streamGeometry1);
double num2 = 5.0 - pen.Thickness;
Vector vector7 = vector1 * num2;
Vector vector8 = vector2 * num2;
StreamGeometry streamGeometry2 = new StreamGeometry();
StreamGeometryContext streamGeometryContext2 = streamGeometry2.Open();
streamGeometryContext2.BeginFigure(anchorPoint, true, true);
streamGeometryContext2.LineTo(anchorPoint + vector8, true, false);
streamGeometryContext2.LineTo(anchorPoint + vector7 + vector8, true, false);
streamGeometryContext2.LineTo(anchorPoint + vector7, true, false);
streamGeometryContext2.Close();
streamGeometry2.Freeze();
drawingContext.DrawGeometry(brush, pen, (System.Windows.Media.Geometry)streamGeometry2);
}
private void DrawEdgeAdorner(DrawingContext drawingContext, Point anchorPoint, Matrix matrix, Brush brush, Pen pen, Rect bounds)
{
if (SizeAdorner.SkipAdorner(this.EdgeFlags, matrix, bounds))
{
return;
}
Vector vector1 = new Vector(1.0, 0.0) * matrix;
Vector vector2 = new Vector(0.0, 1.0) * matrix;
vector1.Normalize();
vector2.Normalize();
double num1 = this.TestFlags(EdgeFlags.Right) ? -1.0 : 1.0;
double num2 = this.TestFlags(EdgeFlags.Bottom) ? -1.0 : 1.0;
switch (this.EdgeFlags & EdgeFlags.TopOrBottom)
{
case EdgeFlags.None:
anchorPoint -= 0.5 * (13.0 - pen.Thickness) * vector2;
break;
case EdgeFlags.Top:
case EdgeFlags.Bottom:
anchorPoint -= (15.0 - 0.5 * pen.Thickness) * vector2 * num2;
break;
}
switch (this.EdgeFlags & EdgeFlags.LeftOrRight)
{
case EdgeFlags.None:
anchorPoint -= 0.5 * (13.0 - pen.Thickness) * vector1;
break;
case EdgeFlags.Left:
case EdgeFlags.Right:
anchorPoint -= (15.0 - 0.5 * pen.Thickness) * vector1 * num1;
break;
}
bool flag = this.TestFlags(EdgeFlags.LeftOrRight);
double num3 = (flag ? 4.0 : 13.0) - pen.Thickness;
double num4 = (flag ? 13.0 : 4.0) - pen.Thickness;
vector1 *= num3 * num1;
Vector vector3 = vector2 * (num4 * num2);
StreamGeometry streamGeometry = new StreamGeometry();
StreamGeometryContext streamGeometryContext = streamGeometry.Open();
streamGeometryContext.BeginFigure(anchorPoint, true, true);
streamGeometryContext.LineTo(anchorPoint + vector3, true, false);
streamGeometryContext.LineTo(anchorPoint + vector1 + vector3, true, false);
streamGeometryContext.LineTo(anchorPoint + vector1, true, false);
streamGeometryContext.Close();
streamGeometry.Freeze();
if (this.IsEnabled)
{
drawingContext.DrawGeometry(brush, pen, (System.Windows.Media.Geometry)streamGeometry);
}
else
{
drawingContext.DrawGeometry((Brush)Brushes.Transparent, (Pen)null, (System.Windows.Media.Geometry)streamGeometry);
Vector vector4 = flag ? vector3 : vector1;
drawingContext.DrawLine(pen, anchorPoint, anchorPoint + vector4);
}
}
