public Rect(Point location, Size size)
{
this.x = location.X;
this.y = location.Y;
this.width = size.Width;
this.height = size.Height;
}
/// <summary>
/// Initializes a new instance of the <see cref="Rect"/> structure.
/// </summary>
/// <param name="size">The size of the rectangle.</param>
public Rect(Size size)
{
_x = 0;
_y = 0;
_width = size.Width;
_height = size.Height;
}
protected override Avalonia.Size ArrangeOverride(Avalonia.Size finalSize)
{
if (Element == null)
{
return(finalSize);
}
Element.IsInNativeLayout = true;
for (var i = 0; i < ElementController.LogicalChildren.Count; i++)
{
var child = ElementController.LogicalChildren[i] as VisualElement;
if (child == null)
{
continue;
}
IVisualElementRenderer renderer = Platform.GetRenderer(child);
if (renderer == null)
{
continue;
}
Rectangle bounds = child.Bounds;
Control control = renderer.GetNativeElement();
Rect childFinal = new Rect(bounds.X, bounds.Y, Math.Max(0, bounds.Width), Math.Max(0, bounds.Height));
control.Arrange(childFinal);
}
Element.IsInNativeLayout = false;
return(finalSize);
}
/// <summary>
/// Initializes a new instance of the <see cref="Rect"/> structure.
/// </summary>
/// <param name="position">The position of the rectangle.</param>
/// <param name="size">The size of the rectangle.</param>
public Rect(Point position, Size size)
{
_x = position.X;
_y = position.Y;
_width = size.Width;
_height = size.Height;
}
protected override Size MeasureOverride(Size availableSize)
{
if (double.IsNaN(Width))
{
Width = 0;
}
return new Size(Width, 0);
}
protected override Avalonia.Size MeasureOverride(Avalonia.Size availableSize)
{
if (Element == null || availableSize.Width * availableSize.Height == 0)
{
return(new Avalonia.Size(0, 0));
}
Element.IsInNativeLayout = true;
for (var i = 0; i < ElementController.LogicalChildren.Count; i++)
{
var child = ElementController.LogicalChildren[i] as VisualElement;
if (child == null)
{
continue;
}
IVisualElementRenderer renderer = Platform.GetOrCreateRenderer(child);
if (renderer == null)
{
continue;
}
Control control = renderer.GetNativeElement();
if (control.Bounds.Width != child.Width || control.Bounds.Height != child.Height)
{
double width = child.Width <= -1 ? Bounds.Width : child.Width;
double height = child.Height <= -1 ? Bounds.Height : child.Height;
control.Measure(new Avalonia.Size(width, height));
}
}
Avalonia.Size result;
if (double.IsInfinity(availableSize.Width) || double.IsPositiveInfinity(availableSize.Height))
{
Size request = Element.Measure(availableSize.Width, availableSize.Height, MeasureFlags.IncludeMargins).Request;
result = new Avalonia.Size(request.Width, request.Height);
}
else
{
result = availableSize;
}
Element.IsInNativeLayout = false;
if (Double.IsPositiveInfinity(result.Height))
{
result.WithHeight(0.0);
}
if (Double.IsPositiveInfinity(result.Width))
{
result.WithWidth(0.0);
}
return(result);
}
private A.Point GetTextOrigin(ShapeStyle style, ref Rect2 rect, ref A.Size size)
{
double ox, oy;
switch (style.TextStyle.TextHAlignment)
{
case TextHAlignment.Left:
ox = rect.X;
break;
case TextHAlignment.Right:
ox = rect.Right - size.Width;
break;
case TextHAlignment.Center:
default:
ox = (rect.Left + rect.Width / 2.0) - (size.Width / 2.0);
break;
}
switch (style.TextStyle.TextVAlignment)
{
case TextVAlignment.Top:
oy = rect.Y;
break;
case TextVAlignment.Bottom:
oy = rect.Bottom - size.Height;
break;
case TextVAlignment.Center:
default:
oy = (rect.Bottom - rect.Height / 2f) - (size.Height / 2f);
break;
}
return(new A.Point(ox, oy));
}
public virtual SizeRequest GetDesiredSize(double widthConstraint, double heightConstraint)
{
if (Control == null)
{
return(new SizeRequest());
}
var constraint = new Avalonia.Size(widthConstraint, heightConstraint);
if (Element.HeightRequest == -1)
{
Control.Height = double.NaN;
}
if (Element.WidthRequest == -1)
{
Control.Width = double.NaN;
}
Control.Measure(constraint);
return(new SizeRequest(new Size(Math.Ceiling(Control.DesiredSize.Width), Math.Ceiling(Control.DesiredSize.Height))));
}
/// <summary>
/// Convert from WPF size to core size.
/// </summary>
public static RSize Convert(Size s)
{
return new RSize(s.Width, s.Height);
}
protected virtual Size ArrangeOverride(Size finalSize)
{
return finalSize;
}
protected sealed override void ArrangeCore(Rect finalRect)
{
Point origin = new Point(
finalRect.Left + this.Margin.Left,
finalRect.Top + this.Margin.Top);
Size size = new Size(
Math.Max(0, finalRect.Width - this.Margin.Left - this.Margin.Right),
Math.Max(0, finalRect.Height - this.Margin.Top - this.Margin.Bottom));
if (this.HorizontalAlignment != HorizontalAlignment.Stretch)
{
size = new Size(Math.Min(size.Width, this.DesiredSize.Width), size.Height);
}
if (this.VerticalAlignment != VerticalAlignment.Stretch)
{
size = new Size(size.Width, Math.Min(size.Height, this.DesiredSize.Height));
}
Size taken = this.ArrangeOverride(size);
size = new Size(
Math.Min(taken.Width, size.Width),
Math.Min(taken.Height, size.Height));
switch (this.HorizontalAlignment)
{
case HorizontalAlignment.Center:
origin.X += (finalRect.Width - size.Width) / 2;
break;
case HorizontalAlignment.Right:
origin.X += finalRect.Width - size.Width;
break;
}
switch (this.VerticalAlignment)
{
case VerticalAlignment.Center:
origin.Y += (finalRect.Height - size.Height) / 2;
break;
case VerticalAlignment.Bottom:
origin.Y += finalRect.Height - size.Height;
break;
}
base.ArrangeCore(new Rect(origin, size));
}
protected virtual Size MeasureCore(Size availableSize)
{
return new Size();
}
/// <summary>
/// Constrains the size.
/// </summary>
/// <param name="constraint">The size to constrain to.</param>
/// <returns>The constrained size.</returns>
public Size Constrain(Size constraint)
{
return new Size(
Math.Min(_width, constraint._width),
Math.Min(_height, constraint._height));
}
public static Rect Inflate(Rect rect, Size size)
{
return Rect.Inflate(rect, size.Width, size.Height);
}
protected override Size ArrangeOverride(Size finalSize)
{
_viewport = new Size(finalSize.Width, finalSize.Height / _lineSize.Height);
_extent = new Size(_lineSize.Width, itemCount + 1);
InvalidateScroll?.Invoke();
return finalSize;
}
public static bool Equals(Size size1, Size size2)
{
return size1.Equals(size2);
}
public bool Equals(Size value)
{
return this.width == value.Width && this.height == value.Height;
}
protected override Size MeasureOverride(Size availableSize)
{
using (var line = new FormattedText(
"Item 100",
TextBlock.GetFontFamily(this),
TextBlock.GetFontSize(this),
TextBlock.GetFontStyle(this),
TextAlignment.Left,
TextBlock.GetFontWeight(this)))
{
line.Constraint = availableSize;
_lineSize = line.Measure();
return new Size(_lineSize.Width, _lineSize.Height * itemCount);
}
}
public Rect(Size size)
{
this.x = this.y = 0.0;
this.width = size.Width;
this.height = size.Height;
}
public static AM.Geometry?ToGeometry(this Path path, bool isFilled)
{
if (path.Commands == null)
{
return(null);
}
var streamGeometry = new AM.StreamGeometry();
using var streamGeometryContext = streamGeometry.Open();
streamGeometryContext.SetFillRule(path.FillType.ToSKPathFillType());
bool endFigure = false;
bool haveFigure = false;
for (int i = 0; i < path.Commands.Count; i++)
{
var pathCommand = path.Commands[i];
var isLast = i == path.Commands.Count - 1;
switch (pathCommand)
{
case MoveToPathCommand moveToPathCommand:
{
if (endFigure == true && haveFigure == false)
{
return(null);
}
if (haveFigure == true)
{
streamGeometryContext.EndFigure(false);
}
if (isLast == true)
{
return(streamGeometry);
}
else
{
if (path.Commands[i + 1] is MoveToPathCommand)
{
return(streamGeometry);
}
if (path.Commands[i + 1] is ClosePathCommand)
{
return(streamGeometry);
}
}
endFigure = true;
haveFigure = false;
var x = moveToPathCommand.X;
var y = moveToPathCommand.Y;
var point = new A.Point(x, y);
streamGeometryContext.BeginFigure(point, isFilled); // TODO: isFilled
}
break;
case LineToPathCommand lineToPathCommand:
{
if (endFigure == false)
{
return(null);
}
haveFigure = true;
var x = lineToPathCommand.X;
var y = lineToPathCommand.Y;
var point = new A.Point(x, y);
streamGeometryContext.LineTo(point);
}
break;
case ArcToPathCommand arcToPathCommand:
{
if (endFigure == false)
{
return(null);
}
haveFigure = true;
var x = arcToPathCommand.X;
var y = arcToPathCommand.Y;
var point = new A.Point(x, y);
var rx = arcToPathCommand.Rx;
var ry = arcToPathCommand.Ry;
var size = new A.Size(rx, ry);
var rotationAngle = arcToPathCommand.XAxisRotate;
var isLargeArc = arcToPathCommand.LargeArc == PathArcSize.Large;
var sweep = arcToPathCommand.Sweep.ToSweepDirection();
streamGeometryContext.ArcTo(point, size, rotationAngle, isLargeArc, sweep);
}
break;
case QuadToPathCommand quadToPathCommand:
{
if (endFigure == false)
{
return(null);
}
haveFigure = true;
var x0 = quadToPathCommand.X0;
var y0 = quadToPathCommand.Y0;
var x1 = quadToPathCommand.X1;
var y1 = quadToPathCommand.Y1;
var control = new A.Point(x0, y0);
var endPoint = new A.Point(x1, y1);
streamGeometryContext.QuadraticBezierTo(control, endPoint);
}
break;
case CubicToPathCommand cubicToPathCommand:
{
if (endFigure == false)
{
return(null);
}
haveFigure = true;
var x0 = cubicToPathCommand.X0;
var y0 = cubicToPathCommand.Y0;
var x1 = cubicToPathCommand.X1;
var y1 = cubicToPathCommand.Y1;
var x2 = cubicToPathCommand.X2;
var y2 = cubicToPathCommand.Y2;
var point1 = new A.Point(x0, y0);
var point2 = new A.Point(x1, y1);
var point3 = new A.Point(x2, y2);
streamGeometryContext.CubicBezierTo(point1, point2, point3);
}
break;
case ClosePathCommand _:
{
if (endFigure == false)
{
return(null);
}
if (haveFigure == false)
{
return(null);
}
endFigure = false;
haveFigure = false;
streamGeometryContext.EndFigure(true);
}
break;
default:
break;
}
}
if (endFigure)
{
if (haveFigure == false)
{
return(null);
}
streamGeometryContext.EndFigure(false);
}
return(streamGeometry);
}
public void Inflate(Size size)
{
this.Inflate(size.Width, size.Height);
}
protected sealed override Size MeasureCore(Size availableSize)
{
this.ApplyTemplate();
availableSize = new Size(
Math.Max(0, availableSize.Width - this.Margin.Left - this.Margin.Right),
Math.Max(0, availableSize.Height - this.Margin.Top - this.Margin.Bottom));
Size size = this.MeasureOverride(availableSize);
size = new Size(
Math.Min(availableSize.Width, size.Width + this.Margin.Left + this.Margin.Right),
Math.Min(availableSize.Height, size.Height + this.Margin.Top + this.Margin.Bottom));
return size;
}
protected virtual Size MeasureOverride(Size constraint)
{
return new Size();
}
public void Measure(Size availableSize)
{
this.measureCalled = true;
this.previousMeasureSize = availableSize;
this.DesiredSize = this.MeasureCore(availableSize);
this.IsMeasureValid = true;
this.IsArrangeValid = false;
}
