internal override SpacePlan Measure(Size availableSpace)
{
if (!RenderingQueue.Any())
{
return(SpacePlan.FullRender(Size.Zero));
}
var lines = DivideTextItemsIntoLines(availableSpace.Width, availableSpace.Height).ToList();
if (!lines.Any())
{
return(SpacePlan.Wrap());
}
var width = lines.Max(x => x.Width);
var height = lines.Sum(x => x.LineHeight);
if (width > availableSpace.Width + Size.Epsilon || height > availableSpace.Height + Size.Epsilon)
{
return(SpacePlan.Wrap());
}
var fullyRenderedItemsCount = lines
.SelectMany(x => x.Elements)
.GroupBy(x => x.Item)
.Count(x => x.Any(y => y.Measurement.IsLast));
if (fullyRenderedItemsCount == RenderingQueue.Count)
{
return(SpacePlan.FullRender(width, height));
}
return(SpacePlan.PartialRender(width, height));
}
public void Measure_NotEnoughHeight()
{
TestPlan
.For(GetPadding)
.MeasureElement(new Size(20, 300))
.CheckMeasureResult(SpacePlan.Wrap());
}
internal override SpacePlan Measure(Size availableSpace)
{
if (!Cells.Any())
{
return(SpacePlan.FullRender(Size.Zero));
}
UpdateColumnsWidth(availableSpace.Width);
var renderingCommands = PlanLayout(availableSpace);
if (!renderingCommands.Any())
{
return(SpacePlan.Wrap());
}
var width = Columns.Sum(x => x.Width);
var height = renderingCommands.Max(x => x.Offset.Y + x.Size.Height);
var tableSize = new Size(width, height);
if (tableSize.Width > availableSpace.Width + Size.Epsilon)
{
return(SpacePlan.Wrap());
}
return(FindLastRenderedRow(renderingCommands) == StartingRowsCount
? SpacePlan.FullRender(tableSize)
: SpacePlan.PartialRender(tableSize));
}
internal override SpacePlan Measure(Size availableSpace)
{
if (NormalizedTurnCount == 0 || NormalizedTurnCount == 2)
{
return(base.Measure(availableSpace));
}
availableSpace = new Size(availableSpace.Height, availableSpace.Width);
var childSpace = base.Measure(availableSpace);
if (childSpace.Type == SpacePlanType.Wrap)
{
return(SpacePlan.Wrap());
}
var targetSpace = new Size(childSpace.Height, childSpace.Width);
if (childSpace.Type == SpacePlanType.FullRender)
{
return(SpacePlan.FullRender(targetSpace));
}
if (childSpace.Type == SpacePlanType.PartialRender)
{
return(SpacePlan.PartialRender(targetSpace));
}
throw new ArgumentException();
}
internal override SpacePlan Measure(Size availableSpace)
{
var targetSpace = new Size(
Math.Abs(availableSpace.Width / ScaleX),
Math.Abs(availableSpace.Height / ScaleY));
var measure = base.Measure(targetSpace);
if (measure.Type == SpacePlanType.Wrap)
{
return(SpacePlan.Wrap());
}
var targetSize = new Size(
Math.Abs(measure.Width * ScaleX),
Math.Abs(measure.Height * ScaleY));
if (measure.Type == SpacePlanType.PartialRender)
{
return(SpacePlan.PartialRender(targetSize));
}
if (measure.Type == SpacePlanType.FullRender)
{
return(SpacePlan.FullRender(targetSize));
}
throw new ArgumentException();
}
internal override SpacePlan Measure(Size availableSpace)
{
return(Type switch
{
LineType.Vertical when availableSpace.Width + Infrastructure.Size.Epsilon >= Size => SpacePlan.FullRender(Size, 0),
LineType.Horizontal when availableSpace.Height + Infrastructure.Size.Epsilon >= Size => SpacePlan.FullRender(0, Size),
_ => SpacePlan.Wrap()
});
public void Measure_FullRender()
{
TestPlan
.For(GetLayers)
.MeasureElement(new Size(800, 600))
.ExpectChildMeasure(MainLayer, new Size(800, 600), SpacePlan.FullRender(500, 400))
.CheckMeasureResult(SpacePlan.FullRender(500, 400));
}
public void Measure_ReturnsWrap_WhenFirstChildWraps()
{
TestPlan
.For(CreateColumnWithTwoItems)
.MeasureElement(new Size(400, 300))
.ExpectChildMeasure("first", new Size(400, 300), SpacePlan.Wrap())
.CheckMeasureResult(SpacePlan.Wrap());
}
public void Measure_ReturnsPartialRender_WhenFirstChildReturnsPartialRender()
{
TestPlan
.For(CreateColumnWithTwoItems)
.MeasureElement(new Size(400, 300))
.ExpectChildMeasure("first", new Size(400, 300), SpacePlan.PartialRender(300, 200))
.CheckMeasureResult(SpacePlan.PartialRender(300, 200));
}
public void Draw_WhenFirstChildWraps()
{
TestPlan
.For(CreateColumnWithTwoItems)
.DrawElement(new Size(400, 300))
.ExpectChildMeasure("first", new Size(400, 300), SpacePlan.Wrap())
.CheckDrawResult();
}
public void Measure_AcceptsWrap()
{
TestPlan
.For(GetPadding)
.MeasureElement(new Size(400, 300))
.ExpectChildMeasure(new Size(340, 260), SpacePlan.Wrap())
.CheckMeasureResult(SpacePlan.Wrap());
}
public void Measure_AcceptsPartialRender()
{
TestPlan
.For(GetPadding)
.MeasureElement(new Size(400, 300))
.ExpectChildMeasure(new Size(340, 260), SpacePlan.PartialRender(40, 160))
.CheckMeasureResult(SpacePlan.PartialRender(100, 200));
}
public void Measure_General_EnoughSpace()
{
TestPlan
.For(GetPadding)
.MeasureElement(new Size(400, 300))
.ExpectChildMeasure(new Size(340, 260), SpacePlan.FullRender(140, 60))
.CheckMeasureResult(SpacePlan.FullRender(200, 100));
}
internal override SpacePlan Measure(Size availableSpace)
{
if (Child == null || IsRendered)
{
return(SpacePlan.FullRender(0, 0));
}
return(base.Measure(availableSpace));
}
internal override SpacePlan Measure(Size availableSpace)
{
if (Child == null || !FirstPageWasSkipped)
{
return(SpacePlan.FullRender(Size.Zero));
}
return(Child.Measure(availableSpace));
}
internal override SpacePlan Measure(Size availableSpace)
{
if (IsRendered)
{
return(SpacePlan.FullRender(0, 0));
}
return(SpacePlan.PartialRender(Size.Zero));
}
public void Measure_ReturnsFullRender_WhenSecondChildReturnsFullRender()
{
TestPlan
.For(CreateColumnWithTwoItems)
.MeasureElement(new Size(400, 300))
.ExpectChildMeasure("first", new Size(400, 300), SpacePlan.FullRender(200, 100))
.ExpectChildMeasure("second", new Size(400, 200), SpacePlan.FullRender(100, 50))
.CheckMeasureResult(SpacePlan.FullRender(200, 150));
}
public void Measure_ReturnsWrap_WhenContentReturnsFullRender()
{
TestPlan
.For(CreateDecoration)
.MeasureElement(new Size(400, 300))
.ExpectChildMeasure("before", new Size(400, 300), SpacePlan.FullRender(100, 50))
.ExpectChildMeasure("after", new Size(400, 300), SpacePlan.FullRender(100, 50))
.ExpectChildMeasure("content", new Size(400, 200), SpacePlan.FullRender(150, 100))
.CheckMeasureResult(SpacePlan.FullRender(150, 200));
}
public void Measure_MinHeight_ExpectWrap()
{
TestPlan
.For(x => new Constrained
{
MinHeight = 100
})
.MeasureElement(new Size(400, 50))
.CheckMeasureResult(SpacePlan.Wrap());
}
public void Measure_MaxWidth_Empty()
{
TestPlan
.For(x => new Constrained
{
MaxWidth = 100
})
.MeasureElement(new Size(150, 400))
.CheckMeasureResult(SpacePlan.FullRender(0, 0));
}
public void Measure_MinWidth_ExpectWrap()
{
TestPlan
.For(x => new Constrained
{
MinWidth = 100
})
.MeasureElement(new Size(50, 400))
.CheckMeasureResult(SpacePlan.Wrap());
}
public void Measure_MaxHeight_Empty()
{
TestPlan
.For(x => new Constrained
{
MaxHeight = 100
})
.MeasureElement(new Size(400, 150))
.CheckMeasureResult(SpacePlan.FullRender(0, 0));
}
public void Measure_TakesAvailableSpaceRegardlessOfSize()
{
TestPlan
.For(x => new Image
{
InternalImage = GenerateImage(400, 300)
})
.MeasureElement(new Size(300, 200))
.CheckMeasureResult(SpacePlan.FullRender(300, 200));
}
public void Measure_TakesAvailableSpaceRegardlessOfSize()
{
TestPlan
.For(x => new DynamicImage
{
Source = GenerateImage
})
.MeasureElement(new Size(300, 200))
.CheckMeasureResult(SpacePlan.FullRender(300, 200));
}
public void Measure_Wrap()
{
TestPlan
.For(x => new Unconstrained
{
Child = x.CreateChild()
})
.MeasureElement(new Size(900, 800))
.ExpectChildMeasure(Size.Max, SpacePlan.Wrap())
.CheckMeasureResult(SpacePlan.Wrap());
}
public void Draw_WhenFirstChildPartiallyRenders()
{
TestPlan
.For(CreateColumnWithTwoItems)
.DrawElement(new Size(400, 300))
.ExpectChildMeasure("first", new Size(400, 300), SpacePlan.PartialRender(200, 100))
.ExpectCanvasTranslate(0, 0)
.ExpectChildDraw("first", new Size(400, 100))
.ExpectCanvasTranslate(0, 0)
.CheckDrawResult();
}
public void Draw_Wrap()
{
TestPlan
.For(x => new MinimalBox
{
Child = x.CreateChild()
})
.DrawElement(new Size(400, 300))
.ExpectChildMeasure(expectedInput: new Size(400, 300), returns: SpacePlan.Wrap())
.CheckDrawResult();
}
internal override SpacePlan Measure(Size availableSpace)
{
var measurement = base.Measure(availableSpace);
if (measurement.Type == SpacePlanType.PartialRender && availableSpace.Height < MinHeight)
{
return(SpacePlan.Wrap());
}
return(measurement);
}
public void Draw_SkipWhenChildWraps()
{
TestPlan
.For(x => new Unconstrained
{
Child = x.CreateChild()
})
.DrawElement(new Size(900, 800))
.ExpectChildMeasure(Size.Max, SpacePlan.Wrap())
.CheckDrawResult();
}
public void Measure_FullRender()
{
TestPlan
.For(x => new Unconstrained
{
Child = x.CreateChild()
})
.MeasureElement(new Size(900, 800))
.ExpectChildMeasure(Size.Max, SpacePlan.FullRender(1200, 1600))
.CheckMeasureResult(SpacePlan.FullRender(Size.Zero));
}
