/// <summary>
/// Interpolates between two colors based on a weight.
/// </summary>
public override object Interpolate(object from, object to, float weight)
{
ElementMargin a = from as ElementMargin;
ElementMargin b = to as ElementMargin;
if (a == null || b == null)
return base.Interpolate(from, to, weight);
return new ElementMargin(
_elementSizeValueInterpolator.Interpolate(a.Left, b.Left, weight) as ElementSize,
_elementSizeValueInterpolator.Interpolate(a.Top, b.Top, weight) as ElementSize,
_elementSizeValueInterpolator.Interpolate(a.Right, b.Right, weight) as ElementSize,
_elementSizeValueInterpolator.Interpolate(a.Bottom, b.Bottom, weight) as ElementSize);
}
/// <summary>
/// Updates the layout of the view.
/// </summary>
public override void LayoutChanged()
{
// set content margins based on tab list size and its orientation
var contentMargin = new ElementMargin();
var tabAlignment = ElementAlignment.Center;
if (TabHeaderList.Orientation == ElementOrientation.Horizontal)
{
if (TabHeaderList.Alignment.Value.HasFlag(ElementAlignment.Bottom))
{
contentMargin.Bottom = ElementSize.FromPixels(TabHeaderList.Height.Value.Pixels);
tabAlignment = ElementAlignment.Top;
}
else
{
contentMargin.Top = ElementSize.FromPixels(TabHeaderList.Height.Value.Pixels);
tabAlignment = ElementAlignment.Bottom;
}
}
else
{
if (TabHeaderList.Alignment.Value.HasFlag(ElementAlignment.Right))
{
contentMargin.Right = ElementSize.FromPixels(TabHeaderList.Width.Value.Pixels);
tabAlignment = ElementAlignment.Left;
}
else
{
contentMargin.Left = ElementSize.FromPixels(TabHeaderList.Width.Value.Pixels);
tabAlignment = ElementAlignment.Right;
}
}
if (AutoAdjustContentMargin)
{
TabContent.Margin.Value = contentMargin;
}
if (AutoAdjustTabListContentAlignment)
{
TabHeaderList.ContentAlignment.Value = tabAlignment;
}
base.LayoutChanged();
}
/// <summary>
/// Sets slider position based on value.
/// </summary>
private void UpdateSliderPosition(float value)
{
float p = (value - Min) / (Max - Min);
var fillTransform = SliderFillRegion.RectTransform;
// set handle offset
float fillWidth = fillTransform.rect.width;
float slideAreaWidth = fillWidth - SliderHandleImageView.Width.Value.Pixels;
float handleOffset = p * slideAreaWidth + SliderFillRegion.Margin.Value.Left.Pixels;
SliderHandleImageView.OffsetFromParent.DirectValue = ElementMargin.FromLeft(new ElementSize(handleOffset, ElementSizeUnit.Pixels));
SliderHandleImageView.LayoutChanged();
// set fill percentage as to match the offset of the handle
float fillP = (handleOffset + SliderHandleImageView.Width.Value.Pixels / 2f) / fillWidth;
SliderFillImageView.Width.DirectValue = new ElementSize(fillP, ElementSizeUnit.Percents);
SliderFillImageView.LayoutChanged();
}
/// <summary>
/// Updates the layout of the view.
/// </summary>
public override void LayoutChanged()
{
float maxWidth = 0f;
float maxHeight = 0f;
float totalWidth = 0f;
float totalHeight = 0f;
bool percentageWidth = false;
bool percentageHeight = false;
bool isHorizontal = Orientation == ElementOrientation.Horizontal;
var children = new List <UIView>();
var childrenToBeSorted = new List <UIView>();
_groupContentContainer.ForEachChild <UIView>(x =>
{
// should this be sorted?
if (x.SortIndex != 0)
{
// yes.
childrenToBeSorted.Add(x);
return;
}
children.Add(x);
}, false);
if (SortDirection == ElementSortDirection.Ascending)
{
children.AddRange(childrenToBeSorted.OrderBy(x => x.SortIndex.Value));
}
else
{
children.AddRange(childrenToBeSorted.OrderByDescending(x => x.SortIndex.Value));
}
// get size of content and set content offsets and alignment
int childCount = children.Count;
int childIndex = 0;
for (int i = 0; i < childCount; ++i)
{
var view = children[i];
// don't group disabled views
if (!view.IsLive)
{
if (SetChildVisibility)
{
view.IsVisible.Value = false;
}
continue;
}
if (view.Width.Value.Unit == ElementSizeUnit.Percents)
{
if (isHorizontal)
{
Debug.LogWarning(String.Format("[MarkLight] Unable to group view \"{0}\" horizontally as it doesn't specify its width in pixels or elements.", view.GameObjectName));
continue;
}
else
{
percentageWidth = true;
}
}
if (view.Height.Value.Unit == ElementSizeUnit.Percents)
{
if (!isHorizontal)
{
Debug.LogWarning(String.Format("[MarkLight] Unable to group view \"{0}\" vertically as it doesn't specify its height in pixels or elements.", view.GameObjectName));
continue;
}
else
{
percentageHeight = true;
}
}
// set offsets and alignment
var offset = new ElementMargin(
new ElementSize(isHorizontal ? totalWidth + Spacing.Value.Pixels * childIndex : 0f, ElementSizeUnit.Pixels),
new ElementSize(!isHorizontal ? totalHeight + Spacing.Value.Pixels * childIndex : 0f, ElementSizeUnit.Pixels));
view.OffsetFromParent.DirectValue = offset;
// set desired alignment if it is valid for the orientation otherwise use defaults
var alignment = isHorizontal ? ElementAlignment.Left : ElementAlignment.Top;
var desiredAlignment = ContentAlignment.IsSet ? ContentAlignment : view.Alignment;
if (isHorizontal && (desiredAlignment == ElementAlignment.Top || desiredAlignment == ElementAlignment.Bottom ||
desiredAlignment == ElementAlignment.TopLeft || desiredAlignment == ElementAlignment.BottomLeft))
{
view.Alignment.DirectValue = alignment | desiredAlignment;
}
else if (!isHorizontal && (desiredAlignment == ElementAlignment.Left || desiredAlignment == ElementAlignment.Right ||
desiredAlignment == ElementAlignment.TopLeft || desiredAlignment == ElementAlignment.TopRight))
{
view.Alignment.DirectValue = alignment | desiredAlignment;
}
else
{
view.Alignment.DirectValue = alignment;
}
// get size of content
if (!percentageWidth)
{
totalWidth += view.Width.Value.Pixels;
maxWidth = view.Width.Value.Pixels > maxWidth ? view.Width.Value.Pixels : maxWidth;
}
if (!percentageHeight)
{
totalHeight += view.Height.Value.Pixels;
maxHeight = view.Height.Value.Pixels > maxHeight ? view.Height.Value.Pixels : maxHeight;
}
// update child layout
view.RectTransformChanged();
++childIndex;
// update child visibility
if (SetChildVisibility)
{
view.IsVisible.Value = true;
}
}
// set width and height
float totalSpacing = childCount > 1 ? (childIndex - 1) * Spacing.Value.Pixels : 0f;
bool adjustsToContent = false;
if (!Width.IsSet)
{
// if width is not explicitly set then adjust to content
if (!percentageWidth)
{
// add margins
totalWidth += isHorizontal ? totalSpacing : 0f;
totalWidth += Margin.Value.Left.Pixels + Margin.Value.Right.Pixels;
maxWidth += Margin.Value.Left.Pixels + Margin.Value.Right.Pixels;
// adjust width to content
Width.DirectValue = new ElementSize(isHorizontal ? totalWidth : maxWidth, ElementSizeUnit.Pixels);
adjustsToContent = true;
}
else
{
Width.DirectValue = new ElementSize(1, ElementSizeUnit.Percents);
}
}
if (!Height.IsSet)
{
// if height is not explicitly set then adjust to content
if (!percentageHeight)
{
// add margins
totalHeight += !isHorizontal ? totalSpacing : 0f;
totalHeight += Margin.Value.Top.Pixels + Margin.Value.Bottom.Pixels;
maxHeight += Margin.Value.Top.Pixels + Margin.Value.Bottom.Pixels;
// adjust height to content
Height.DirectValue = new ElementSize(!isHorizontal ? totalHeight : maxHeight, ElementSizeUnit.Pixels);
adjustsToContent = true;
}
else
{
Height.DirectValue = new ElementSize(1, ElementSizeUnit.Percents);
}
}
if (!PropagateChildLayoutChanges.IsSet)
{
// don't propagate changes if width and height isn't adjusted to content
PropagateChildLayoutChanges.DirectValue = adjustsToContent;
}
base.LayoutChanged();
}
/// <summary>
/// Value converter for Margin type.
/// </summary>
public override ConversionResult Convert(object value, ValueConverterContext context)
{
if (value == null)
{
return(base.Convert(value, context));
}
Type valueType = value.GetType();
if (valueType == _type)
{
return(base.Convert(value, context));
}
else if (valueType == _stringType)
{
var stringValue = (string)value;
try
{
string[] valueList;
valueList = stringValue.Split(',').ToArray();
ElementMargin convertedValue = null;
if (valueList.Length == 1)
{
convertedValue = new ElementMargin(ElementSize.Parse(valueList[0], context.UnitSize));
}
else if (valueList.Length == 2)
{
convertedValue = new ElementMargin(
ElementSize.Parse(valueList[0], context.UnitSize),
ElementSize.Parse(valueList[1], context.UnitSize));
}
else if (valueList.Length == 3)
{
convertedValue = new ElementMargin(
ElementSize.Parse(valueList[0], context.UnitSize),
ElementSize.Parse(valueList[1], context.UnitSize),
ElementSize.Parse(valueList[2], context.UnitSize));
}
else if (valueList.Length == 4)
{
convertedValue = new ElementMargin(
ElementSize.Parse(valueList[0], context.UnitSize),
ElementSize.Parse(valueList[1], context.UnitSize),
ElementSize.Parse(valueList[2], context.UnitSize),
ElementSize.Parse(valueList[3], context.UnitSize));
}
else
{
return(StringConversionFailed(value));
}
return(new ConversionResult(convertedValue));
}
catch (Exception e)
{
return(ConversionFailed(value, e));
}
}
else
{
// attempt to convert using system type converter
try
{
var convertedValue = System.Convert.ToInt32(value, CultureInfo.InvariantCulture);
return(new ConversionResult(convertedValue));
}
catch (Exception e)
{
return(ConversionFailed(value, e));
}
}
}
/// <summary>
/// Converts value to string.
/// </summary>
public override string ConvertToString(object value)
{
ElementMargin margin = value as ElementMargin;
return(margin.ToString());
}
