//void IVisualRenderer.Arrange<TRenderSize>(TRenderSize availableSpace,
// IRenderContext renderContext)
//{
// ReplacingVisual.Arrange(availableSpace, renderContext);
//}
public virtual ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
where TRenderSize : IRenderSize
{
return(availableSpace.ToValueSize());
//return ReplacingVisual.Measure(availableSpace, measureContext);
}
public override ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
{
var res = _renderer.Measure(this, Orientation, availableSpace, measureContext);
return(res);
}
public override ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
{
if (!TryGetImage(availableSpace, out var img))
{
return(ValueSize.Empty);
}
var size = measureContext.MeasureImage(img);
var width = Width ?? Double.NaN;
var height = Height ?? Double.NaN;
if (!Double.IsNaN(width) && !Double.IsNaN(height))
{
return(new ValueSize(width, height));
}
if (!Double.IsNaN(height))
{
var scale = height / size.Height;
return(new ValueSize(size.Width * scale, height));
}
if (!Double.IsNaN(width))
{
var scale = width / size.Height;
return(new ValueSize(height, size.Width * scale));
}
return(size);
}
public override ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
{
if (!TryGetCamera(out var camera))
{
return(ValueSize.Empty);
}
if (availableSpace.Height.AreEqualEnough(0))
{
return(availableSpace.ToValueSize());
}
var aspect = availableSpace.Width / availableSpace.Height;
if (aspect.AreEqualEnough(camera.AspectRatio))
{
return(availableSpace.ToValueSize());
}
if (aspect > camera.AspectRatio) //available is wider
{
var sz = new ValueSize(availableSpace.Height * camera.AspectRatio,
availableSpace.Height);
return(sz);
}
else //taller
{
var sz = new ValueSize(availableSpace.Width / camera.AspectRatio,
availableSpace.Width);
return(sz);
}
}
public virtual ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
where TRenderSize : IRenderSize
{
measureContext.TryGetElementSize(this, availableSpace, out _measuredSize);
return(_measuredSize);
}
public override ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
{
//var font = GetFont(measureContext);
var size = measureContext.MeasureString(Text, Font);
return(size);
}
public override ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
{
//Debug.WriteLine("measure hrule");
if (!(measureContext.ViewState is { }))
ValueSize IVisualRenderer.Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
{
if (Content is {} content)
{
return(measureContext.MeasureElement(content, availableSpace));
}
return(ValueSize.Empty);
}
public override ValueSize Measure <TRenderSize>(IVisualElement container,
Orientations orientation,
TRenderSize availableSpace,
IMeasureContext measureContext)
{
_currentRow = 0;
_currentY = 0;
RowHeights.Clear();
return(base.Measure(container, orientation, availableSpace, measureContext));
}
public override void ArrangeContent(IMeasureContext context, RectangleF bounds)
{
base.ArrangeContent(context, bounds);
this.headRect = this.GetHeadRect(bounds);
this.tailRect = this.GetTailRect(bounds);
this.leftRect = this.GetLeftRect(bounds);
this.rightRect = this.GetRightRect(bounds);
if (this.ShowText && ((double)this.leftSize.Width - (double)this.leftRect.Width > 0.5 || (double)this.leftSize.Height - (double)this.leftRect.Height > 0.5 || ((double)this.rightSize.Width - (double)this.rightRect.Width > 0.5 || (double)this.rightSize.Height - (double)this.rightRect.Height > 0.5)))
{
throw new InvalidSizeException(this.Value);
}
}
public override SizeF MeasureContent(IMeasureContext context, SizeF size)
{
SizeF sizeF = base.MeasureContent(context, size);
this.headSize = context.MeasureString(this.headText);
this.tailSize = context.MeasureString(this.tailText);
this.leftSize = context.MeasureString(this.leftText);
this.rightSize = context.MeasureString(this.rightText);
if (!this.Stretch)
{
sizeF.Width = Math.Min(size.Width, sizeF.Width + this.headSize.Width + this.headSize.Width);
}
return(sizeF);
}
public override SizeF MeasureContent(IMeasureContext context, SizeF size)
{
SizeF sizeF = base.MeasureContent(context, size);
if (float.IsInfinity(size.Width))
{
sizeF.Width = this.GetLength() + (float)this.TotalHorizontalClearZone;
}
if (float.IsInfinity(size.Height))
{
sizeF.Height = (float)(this.MinSize.Height * this.Module + this.TotalVerticalClearZone);
}
return(sizeF);
}
public DesignViewUpdater(IViewHost <Bitmap> viewHost,
IRenderer <Bitmap> renderer,
IMeasureContext measureContext,
IRenderContext renderContext,
Int32 maxFramesPerSecond = 60)
: base(viewHost, renderer, maxFramesPerSecond)
{
MeasureContext = measureContext;
RenderContext = renderContext;
_viewHost = viewHost;
_sbSelected = new StringBuilder();
_font = new Font(10, "Segoe UI", FontStyle.Regular);
renderer.Rendering += OnRendering;
}
public override ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
{
if (!_isStyleSet)
{
_isStyleSet = true;
}
var sz = _label.Measure(availableSpace, measureContext);
_offsetX = sz.Height + 5;
var res = new ValueSize(sz.Width + _offsetX, sz.Height);
return(res);
}
public override SizeF MeasureContent(IMeasureContext context, SizeF size)
{
base.MeasureContent(context, size);
if (this.ShowText)
{
this.textSize = context.MeasureString(this.barText);
this.ValidateTextSize(this.textSize, size);
}
if (!this.Stretch)
{
size.Width = this.GetLength();
}
size.Width = Math.Max(size.Width, this.textSize.Width);
return(size);
}
public override ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
{
lock (_cellLock)
{
_columnWidths.Clear();
_rowHeights.Clear();
_totalWidthMeasured = 0.0;
foreach (var kvp in _columnRenderers)
{
var renderer = kvp.Value;
var currentColumn = _rendererColumns[renderer];
var current = renderer.Measure(this, Orientations.Vertical,
availableSpace, measureContext);
_columnWidths[currentColumn] = current.Width;
_totalWidthMeasured += current.Width;
var rowsCount = renderer.RowHeights.Count;
for (var r = 0; r < rowsCount; r++)
{
var rowHeight = renderer.RowHeights[r];
if (!_rowHeights.TryGetValue(r, out var height) ||
height < rowHeight)
{
_rowHeights[r] = rowHeight;
}
}
}
var useHeight = 0.0;
foreach (var h in _rowHeights.Values)
{
useHeight += h;
}
return(new ValueSize(_totalWidthMeasured, useHeight));
}
}
public virtual ValueSize Measure <TRenderSize>(IVisualElement container,
Orientations orientation,
TRenderSize availableSpace,
IMeasureContext measureContext)
where TRenderSize : IRenderSize
{
lock (_measureLock)
{
_currentlyRendering.Clear();
var margin = MeasureImpl(container, measureContext, availableSpace,
orientation, _currentlyRendering,
out var maxWidth, out var maxHeight,
out var totalWidth, out var totalHeight);
return(new ValueSize(Math.Max(totalWidth, maxWidth) + margin.Width,
Math.Max(totalHeight, maxHeight) + margin.Height));
}
}
public override ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
{
if (Children.Count == 0)
{
return(ValueSize.Empty);
}
var useWidth = 0.0;
var useHeight = 0.0;
foreach (var child in Children.GetAllChildren())
{
var childMeasures = measureContext.MeasureElement(child, availableSpace);
useWidth = Math.Max(useWidth, childMeasures.Width);
useHeight = Math.Max(useHeight, childMeasures.Height);
}
return(new ValueSize(useWidth, useHeight));
}
public override ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
{
Double widestLegend;
lock (_legendLock)
{
_legendItemSizes.Clear();
foreach (var item in _legendItems)
{
var sz = item.Measure(availableSpace, measureContext);
_legendItemSizes.Add(sz);
}
widestLegend = _legendItemSizes.Any()
? _legendItemSizes.Max(l => l.Width)
: 0;
}
var side = Math.Min(availableSpace.Width, availableSpace.Height);
if (side.IsZero())
{
return(ValueSize.Empty);
}
_desiredSize.Height = side;
if (side + widestLegend <= availableSpace.Width)
{
side += widestLegend;
}
_desiredSize.Width = side;
return(availableSpace.ToValueSize());
//return _desiredSize;
}
//protected override Boolean OnDataContextChanging(Object? oldValue,
// Object? newValue)
//{
// return base.OnDataContextChanging(oldValue, newValue);
//}
//protected override void OnDataContextChanged(Object? newValue)
//{
// base.OnDataContextChanged(newValue);
//}
//public override void Dispose()
//{
//}
public override ValueSize Measure(IRenderSize availableSpace,
IMeasureContext measureContext)
{
var rowNumbers = _controls.Keys.ToArray();
var remainingSize = new RenderSize(availableSpace.Width, availableSpace.Height);
foreach (var rowNumber in rowNumbers)
{
var sizeRow = _sizes[rowNumber];
sizeRow.Clear();
var currentRowHeight = 0.0;
remainingSize.Width = availableSpace.Width;
var row = _controls[rowNumber];
for (var c = 0; c < row.Count; c++)
{
var ctrlSize = row[c].Measure(remainingSize, measureContext);
if (ctrlSize.Width > _columnWidths[c])
{
_columnWidths[c] = ctrlSize.Width;
}
remainingSize.Width -= ctrlSize.Width;
currentRowHeight = Math.Max(currentRowHeight, ctrlSize.Height);
sizeRow.Add(ctrlSize);
}
remainingSize.Height -= currentRowHeight;
}
var widthNeeded = _columnWidths.Values.Sum(w => w);
var heightNeeded = availableSpace.Height - remainingSize.Height;
return(new ValueSize(widthNeeded, heightNeeded));
}
public override ValueSize Measure <TRenderSize>(IVisualElement container,
Orientations orientation,
TRenderSize availableSpace,
IMeasureContext measureContext)
{
lock (_measureLock)
{
_maxWidth = _maxHeight = 0;
_lastOrientation = orientation;
_currentlyRendering.Clear();
//var remainingSize = new RenderSize(availableSpace.Width,
// availableSpace.Height, availableSpace.Offset);
//var current = new RenderRectangle();
//var totalHeight = 0.0;
//var totalWidth = 0.0;
//var maxWidth = 0.0;
//var maxHeight = 0.0;
//foreach (var child in _visuals.GetAllChildren())
//{
// _currentlyRendering.Add(child);
// current.Size = measureContext.MeasureElement(child, remainingSize);
// var offset = SetChildSize(child, current);
// if (!offset.IsEmpty)
// {
// current.Width += offset.Width;
// current.Height += offset.Height;
// }
// switch (orientation)
// {
// case Orientations.Horizontal:
// if (current.Height > maxHeight)
// maxHeight = current.Height;
// if (_isWrapContent && current.Width + totalWidth > availableSpace.Width
// && totalHeight + maxHeight < availableSpace.Height)
// {
// maxWidth = Math.Max(maxWidth, totalWidth);
// totalHeight += maxHeight;
// current.X = 0;
// current.Y += maxHeight;
// maxHeight = totalWidth = 0;
// }
// current.X += current.Width;
// totalWidth += current.Width;
// remainingSize.Width -= current.Width;
// break;
// case Orientations.Vertical:
// if (current.Width > totalWidth)
// totalWidth = current.Width;
// if (_isWrapContent && current.Height + totalHeight > availableSpace.Height
// && totalWidth + maxWidth < availableSpace.Width)
// {
// maxHeight = Math.Max(maxHeight, totalHeight);
// totalWidth += maxWidth;
// current.Y = 0;
// current.X += maxHeight;
// maxWidth = totalHeight = 0;
// }
// current.Y += current.Height;
// totalHeight += current.Height;
// remainingSize.Height -= current.Height;
// break;
// }
//}
//var margin = container.Margin.GetValue(availableSpace);
var margin = MeasureImpl(container, measureContext, availableSpace,
orientation, _currentlyRendering,
out var maxWidth, out var maxHeight,
out var totalWidth, out var totalHeight);
totalWidth = Math.Max(totalWidth, maxWidth);
totalHeight = Math.Max(totalHeight, maxHeight);
if (orientation == Orientations.Horizontal)
{
totalWidth = _maxWidth * _currentlyRendering.Count;
}
if (orientation == Orientations.Vertical)
{
totalHeight = _maxHeight * _currentlyRendering.Count;
}
return(new ValueSize(totalWidth + margin.Width, totalHeight + margin.Height));
}
//return base.Measure(container, elements, orientation, availableSpace, measureContext);
}
public ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
where TRenderSize : IRenderSize
{
return(availableSpace.ToValueSize());
}
public override void ArrangeContent(IMeasureContext context, RectangleF bounds)
{
this.textRect = this.GetTextRect(bounds);
this.barRect = this.GetBarRect(bounds);
}
public override ValueSize Measure(IRenderSize availableSpace,
IMeasureContext measureContext)
{
return(ValueSize.Empty);
}
public override ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
{
if (!(_itemsControl is { } valid) ||
!(valid.ItemsSource is { }))
public abstract ValueSize Measure <TRenderSize>(TRenderSize availableSpace,
IMeasureContext measureContext)
where TRenderSize : IRenderSize;
protected ValueThickness MeasureImpl <TRenderSize>(IVisualElement container,
IMeasureContext measureContext,
TRenderSize availableSpace,
Orientations orientation,
List <IVisualElement> currentlyRendering,
out Double maxWidth,
out Double maxHeight,
out Double totalWidth,
out Double totalHeight)
where TRenderSize : IRenderSize
{
var remainingSize = new RenderSize(availableSpace.Width,
availableSpace.Height, availableSpace.Offset);
var current = new RenderRectangle();
totalHeight = 0.0;
totalWidth = 0.0;
maxWidth = 0.0;
maxHeight = 0.0;
foreach (var child in _visuals.GetAllChildren())
{
currentlyRendering.Add(child);
current.Size = measureContext.MeasureElement(child, remainingSize);
var offset = SetChildSize(child, current);
if (!offset.IsEmpty)
{
current.Width += offset.Width;
current.Height += offset.Height;
}
switch (orientation)
{
case Orientations.Horizontal:
if (current.Height > maxHeight)
{
maxHeight = current.Height;
}
if (_isWrapContent && current.Width + totalWidth > availableSpace.Width &&
totalHeight + maxHeight < availableSpace.Height)
{
maxWidth = Math.Max(maxWidth, totalWidth);
totalHeight += maxHeight;
current.X = 0;
current.Y += maxHeight;
maxHeight = totalWidth = 0;
}
current.X += current.Width;
totalWidth += current.Width;
remainingSize.Width -= current.Width;
break;
case Orientations.Vertical:
if (current.Width > totalWidth)
{
totalWidth = current.Width;
}
if (_isWrapContent && current.Height + totalHeight > availableSpace.Height &&
totalWidth + maxWidth < availableSpace.Width)
{
maxHeight = Math.Max(maxHeight, totalHeight);
totalWidth += maxWidth;
current.Y = 0;
current.X += maxHeight;
maxWidth = totalHeight = 0;
}
current.Y += current.Height;
totalHeight += current.Height;
remainingSize.Height -= current.Height;
break;
}
}
var margin = container.Margin.GetValue(availableSpace);
return(margin);
}
public virtual SizeF MeasureContent(IMeasureContext context, SizeF size)
{
return(size);
}
public virtual void ArrangeContent(IMeasureContext context, RectangleF bounds)
{
}
