/// <summary>
/// Sets slider position based on value.
/// </summary>
private void UpdateSliderPosition(float value)
{
float p = (value - Min) / (Max - Min);
var fillTransform = SliderFillRegion.RectTransform;
float sliderHandleWidth = SliderHandleImageView.Sprite == null && SliderHandleImageView.Color.a <= 0
? 0 : SliderHandleImageView.Width.Value;
// set handle offset
float fillWidth = fillTransform.rect.width;
float slideAreaWidth = fillWidth - sliderHandleWidth;
float sliderFillMargin = IsReversed ? SliderFillRegion.Margin.Right.Pixels : SliderFillRegion.Margin.Left.Pixels;
float handleOffset = p * slideAreaWidth + sliderFillMargin;
SliderHandleImageView.DisableLayoutUpdate = true;
SliderHandleImageView.OffsetFromParent = IsReversed ?
ElementMargin.FromRight(new ElementSize(handleOffset, ElementSizeUnit.Pixels)) :
ElementMargin.FromLeft(new ElementSize(handleOffset, ElementSizeUnit.Pixels));
SliderHandleImageView.UpdateLayout(false);
SliderHandleImageView.DisableLayoutUpdate = false;
// set fill percentage as to match the offset of the handle
float fillP = (handleOffset + sliderHandleWidth / 2f) / fillWidth;
SliderFillImageView.DisableLayoutUpdate = true;
SliderFillImageView.Width = new ElementSize(fillP, ElementSizeUnit.Percents);
SliderFillImageView.UpdateLayout(false);
SliderFillImageView.DisableLayoutUpdate = false;
}
/// <summary>
/// Updates the layout of the grid.
/// </summary>
public override bool UpdateLayout(bool notifyParent = true)
{
base.UpdateLayout(notifyParent);
bool defaultDisableLayoutUpdate = DisableLayoutUpdate;
DisableLayoutUpdate = true;
var children = new List <UIView>();
Content.ForEach <UIView>(x => children.Add(x), false);
UpdateRowAndColumnDefinitions();
// arrange children into grid
for (int i = 0; i < children.Count; ++i)
{
var child = children[i];
var cellIndex = Cell.GetValue(child);
if (cellIndex == null)
{
if (!(child is GridSplitter))
{
Debug.LogWarning(String.Format("#Delight# {0}: Unable to arrange view \"{1}\" in the grid as it doesn't specify its cell index. Specify cell index as an attached property on the view, e.g. <{1} Grid.CellIndex=\"0,1\" ...>, to put the view in the first row and second column.", Name, child.Name));
}
continue;
}
// calculate width, height and offset of view based on cell index
var columnDefinition = GetColumnDefinition(child);
var rowDefinition = GetRowDefinition(child);
ElementMargin cellOffset = new ElementMargin();
cellOffset.Left = columnDefinition.ActualOffset;
cellOffset.Top = rowDefinition.ActualOffset;
// update child layout
if (!cellOffset.Equals(child.OffsetFromParent) ||
!columnDefinition.ActualWidth.Equals(child.Width) ||
!rowDefinition.ActualHeight.Equals(child.Height) ||
child.Alignment != ElementAlignment.TopLeft)
{
bool defaultDisableChildLayoutUpdate = child.DisableLayoutUpdate;
child.DisableLayoutUpdate = true;
child.OffsetFromParent = cellOffset;
child.Width = columnDefinition.ActualWidth;
child.Height = rowDefinition.ActualHeight;
child.Alignment = ElementAlignment.TopLeft;
child.UpdateLayout(false);
child.DisableLayoutUpdate = defaultDisableChildLayoutUpdate;
}
}
DisableLayoutUpdate = defaultDisableLayoutUpdate;
return(false);
}
public virtual void ScrollTo(int index, ElementAlignment?alignment = null, ElementMargin offset = null)
{
if (index < 0 || index >= Count)
{
return;
}
ScrollTo(this[index], alignment, offset);
}
public virtual void ScrollTo(T item, ElementAlignment?alignment = null, ElementMargin offset = null)
{
Notify(new CollectionSelectionEventArgs
{
ChangeAction = CollectionChangeAction.ScrollTo,
Item = item,
Alignment = alignment,
Offset = offset
});
}
/// <summary>
/// Gets current handle offset as vector.
/// </summary>
public Vector2 GetHandleOffset()
{
if (OffsetFromParent == null)
{
OffsetFromParent = new ElementMargin();
}
return(new Vector2(OffsetFromParent.Left.Pixels,
OffsetFromParent.Top.Pixels));
}
public virtual void Select(T item, ElementAlignment?alignment = null, ElementMargin offset = null, bool scrollTo = false)
{
Notify(new CollectionSelectionEventArgs
{
ChangeAction = CollectionChangeAction.Select,
Item = item,
Alignment = alignment,
Offset = offset,
ScrollTo = scrollTo
});
}
/// <summary>
/// Gets actual offset.
/// </summary>
public ElementMargin GetActualOffset(float actualWidth, float actualHeight)
{
if (Left.Unit == ElementSizeUnit.Percents || Top.Unit == ElementSizeUnit.Percents ||
Right.Unit == ElementSizeUnit.Percents || Bottom.Unit == ElementSizeUnit.Percents)
{
var elementMargin = new ElementMargin();
elementMargin.Left = Left.Unit == ElementSizeUnit.Percents ? actualWidth * Left.Percent : Left.Pixels;
elementMargin.Top = Top.Unit == ElementSizeUnit.Percents ? actualHeight * Top.Percent : Top.Pixels;
elementMargin.Right = Right.Unit == ElementSizeUnit.Percents ? actualWidth * Right.Percent : Right.Pixels;
elementMargin.Bottom = Bottom.Unit == ElementSizeUnit.Percents ? actualHeight * Bottom.Percent : Bottom.Pixels;
return(elementMargin);
}
return(this);
}
/// <summary>
/// Sets content offset as vector.
/// </summary>
private void SetHandleOffset(Vector2 contentOffset)
{
if (OffsetFromParent == null)
{
OffsetFromParent = new ElementMargin();
}
if (IsColumnSplitter)
{
if (OffsetFromParent.Left.Pixels != contentOffset.x)
{
OffsetFromParent.Left.Pixels = contentOffset.x;
}
}
else
{
if (OffsetFromParent.Top.Pixels != contentOffset.y)
{
OffsetFromParent.Top.Pixels = contentOffset.y;
}
}
}
/// <summary>
/// Initializes a new instance of the class.
/// </summary>
public VirtualItem(ElementSize width, ElementSize height)
{
Width = width != null ? new ElementSize(width) : ElementSize.FromPercents(1);
Height = height != null ? new ElementSize(height) : ElementSize.FromPercents(1);
Offset = new ElementMargin();
}
/// <summary>
/// Initializes a new instance of the class.
/// </summary>
public VirtualItem()
{
Width = ElementSize.FromPercents(1);
Height = ElementSize.FromPercents(1);
Offset = new ElementMargin();
}
/// <summary>
/// Updates the layout of the group.
/// </summary>
public override bool UpdateLayout(bool notifyParent = true)
{
bool defaultDisableLayoutUpdate = DisableLayoutUpdate;
DisableLayoutUpdate = true;
bool hasNewSize = false;
float maxWidth = 0f;
float maxHeight = 0f;
float totalWidth = 0f;
float totalHeight = 0f;
bool percentageWidth = false;
bool percentageHeight = false;
bool isHorizontal = Orientation == ElementOrientation.Horizontal;
List <UIView> children = new List <UIView>();
this.ForEach <UIView>(x =>
{
children.Add(x);
}, false);
// get size of content and set content offsets and alignment
var spacing = Spacing ?? ElementSize.Default;
int childCount = children.Count;
int childIndex = 0;
for (int i = 0; i < childCount; ++i)
{
var childView = children[i];
if (!childView.IsActive)
{
// don't group inactive views
continue;
}
var childWidth = childView.OverrideWidth ?? (childView.Width ?? ElementSize.Default);
var childHeight = childView.OverrideHeight ?? (childView.Height ?? ElementSize.Default);
if (childWidth.Unit == ElementSizeUnit.Percents)
{
if (isHorizontal)
{
Debug.LogWarning(String.Format("#Delight# Unable to group view \"{0}\" horizontally as it doesn't specify its width in pixels.", childView.Name));
continue;
}
else
{
percentageWidth = true;
}
}
if (childHeight.Unit == ElementSizeUnit.Percents)
{
if (!isHorizontal)
{
Debug.LogWarning(String.Format("#Delight# Unable to group view \"{0}\" vertically as it doesn't specify its height in pixels or elements.", childView.Name));
continue;
}
else
{
percentageHeight = true;
}
}
bool defaultDisableChildLayoutUpdate = childView.DisableLayoutUpdate;
childView.DisableLayoutUpdate = true;
// set offsets and alignment
var offset = new ElementMargin(
new ElementSize(isHorizontal ? totalWidth + spacing.Pixels * childIndex : 0f, ElementSizeUnit.Pixels),
new ElementSize(!isHorizontal ? totalHeight + spacing.Pixels * childIndex : 0f, ElementSizeUnit.Pixels));
// set desired alignment if it is valid for the orientation otherwise use defaults
var alignment = ElementAlignment.Center;
var defaultAlignment = isHorizontal ? ElementAlignment.Left : ElementAlignment.Top;
var desiredAlignment = !ContentAlignmentProperty.IsUndefined(this) ? ContentAlignment : childView.Alignment;
if (isHorizontal && (desiredAlignment == ElementAlignment.Top || desiredAlignment == ElementAlignment.Bottom ||
desiredAlignment == ElementAlignment.TopLeft || desiredAlignment == ElementAlignment.BottomLeft))
{
alignment = defaultAlignment | desiredAlignment;
}
else if (!isHorizontal && (desiredAlignment == ElementAlignment.Left || desiredAlignment == ElementAlignment.Right ||
desiredAlignment == ElementAlignment.TopLeft || desiredAlignment == ElementAlignment.TopRight))
{
alignment = defaultAlignment | desiredAlignment;
}
else
{
alignment = defaultAlignment;
}
// get size of content
if (!percentageWidth)
{
totalWidth += childWidth;
maxWidth = childWidth.Pixels > maxWidth ? childWidth.Pixels : maxWidth;
}
if (!percentageHeight)
{
totalHeight += childHeight;
maxHeight = childHeight.Pixels > maxHeight ? childHeight.Pixels : maxHeight;
}
// update child layout
if (!offset.Equals(childView.OffsetFromParent) || alignment != childView.Alignment)
{
childView.OffsetFromParent = offset;
childView.Alignment = alignment;
childView.UpdateLayout(false);
}
++childIndex;
childView.DisableLayoutUpdate = defaultDisableChildLayoutUpdate;
}
// set width and height
float totalSpacing = childCount > 1 ? (childIndex - 1) * spacing.Pixels : 0f;
// adjust width to content
if (WidthProperty.IsUndefined(this))
{
if (!percentageWidth)
{
// add margins
var margin = Margin ?? ElementMargin.Default;
totalWidth += isHorizontal ? totalSpacing : 0f;
totalWidth += margin.Left.Pixels + margin.Right.Pixels;
maxWidth += margin.Left.Pixels + margin.Right.Pixels;
// adjust width to content
var newWidth = new ElementSize(isHorizontal ? totalWidth : maxWidth, ElementSizeUnit.Pixels);
if (!newWidth.Equals(Width))
{
OverrideWidth = newWidth;
hasNewSize = true;
}
}
else
{
var newWidth = new ElementSize(1, ElementSizeUnit.Percents);
if (!newWidth.Equals(Width))
{
OverrideWidth = newWidth;
hasNewSize = true;
}
}
}
else if (OverrideWidth != null && !OverrideWidth.Equals(Width))
{
// clear override
OverrideWidth = null;
hasNewSize = true;
}
// adjust height to content
if (HeightProperty.IsUndefined(this))
{
if (!percentageHeight)
{
// add margins
var margin = Margin ?? ElementMargin.Default;
totalHeight += !isHorizontal ? totalSpacing : 0f;
totalHeight += margin.Top.Pixels + margin.Bottom.Pixels;
maxHeight += margin.Top.Pixels + margin.Bottom.Pixels;
// adjust height to content
var newHeight = new ElementSize(!isHorizontal ? totalHeight : maxHeight, ElementSizeUnit.Pixels);
if (!newHeight.Equals(Height))
{
OverrideHeight = newHeight;
hasNewSize = true;
}
}
else
{
var newHeight = new ElementSize(1, ElementSizeUnit.Percents);
if (!newHeight.Equals(Height))
{
OverrideHeight = newHeight;
hasNewSize = true;
}
}
}
else if (OverrideHeight != null && !OverrideHeight.Equals(Height))
{
// clear override
OverrideHeight = null;
hasNewSize = true;
}
DisableLayoutUpdate = defaultDisableLayoutUpdate;
return(base.UpdateLayout(notifyParent) || hasNewSize);
}
