public ICssValue[] Split(ICssValue value)
{
var options = value as CssTupleValue;
if (options != null)
{
return(new[]
{
options.Items[0],
options.Items[1],
options.Items[2],
});
}
return(null);
}
public ICssValue[] Split(ICssValue value)
{
if (value is CssListValue list)
{
var points = list.Items.OfType <Point>();
var x = points.Select(m => m.X).ToArray();
var y = points.Select(m => m.Y).ToArray();
return(new ICssValue[]
{
new CssListValue(x),
new CssListValue(y),
});
}
return(null);
}
public ICssValue[] Split(ICssValue value)
{
if (value is CssListValue list)
{
var repeats = list.Items.OfType <CssImageRepeatsValue>();
var h = repeats.Select(m => m.Horizontal).ToArray();
var v = repeats.Select(m => m.Vertical).ToArray();
return(new ICssValue[]
{
new CssListValue(h),
new CssListValue(v),
});
}
return(null);
}
public Boolean Validate(ICssValue value)
{
var items = value.AsEnumeration();
var count = 0;
foreach (var item in items)
{
if (count > _maximum || !_converter.Validate(item))
{
return(false);
}
count++;
}
return(count >= _minimum);
}
public ICssValue[] Split(ICssValue value)
{
var list = value as CssListValue;
if (list != null)
{
return(new[]
{
CreateMultiple(list, 0),
CreateMultiple(list, 1),
CreateMultiple(list, 2),
CreateMultiple(list, 3),
});
}
return(null);
}
public ICssValue[] Split(ICssValue value)
{
var radius = value as BorderRadius;
if (radius != null)
{
return(new[]
{
Both(radius.Horizontal.Top, radius.Vertical.Top),
Both(radius.Horizontal.Right, radius.Vertical.Right),
Both(radius.Horizontal.Bottom, radius.Vertical.Bottom),
Both(radius.Horizontal.Left, radius.Vertical.Left),
});
}
return(null);
}
public ICssValue[] Split(ICssValue value)
{
var periodic = value as Periodic <ICssValue>;
if (periodic != null)
{
return(new[]
{
periodic.Top,
periodic.Right,
periodic.Bottom,
periodic.Left,
});
}
return(null);
}
public ICssValue[] Split(ICssValue value)
{
var tuple = value as CssTupleValue;
if (tuple != null)
{
return(new[]
{
tuple.Items[0],
GetItem(tuple, 1),
GetItem(tuple, 2),
GetItem(tuple, 3),
});
}
return(null);
}
private static ICssValue CreateValue(CssListValue animatable, CssListValue duration, CssListValue timing, CssListValue delay)
{
var items = (animatable ?? duration ?? timing ?? delay).Items;
var layers = new ICssValue[items.Length];
for (var i = 0; i < items.Length; i++)
{
layers[i] = new CssTupleValue(new[]
{
GetValue(animatable, i),
GetValue(duration, i),
GetValue(timing, i),
GetValue(delay, i),
});
}
return(new CssListValue(layers));
}
public static CssValueList CopyToList(this ICssValue value)
{
var original = value as CssValueList;
if (original == null)
{
return(new CssValueList(value));
}
var newList = new CssValueList();
foreach (var item in original)
{
newList.Add(item);
}
return(newList);
}
public ICssValue[] Split(ICssValue value)
{
var font = value as FontInfo;
if (font == null)
{
var systemFont = value as Constant <SystemFont>;
if (systemFont == null)
{
return(null);
}
return(new[] { systemFont, null, null, null, null, null, null });
}
return(new[] { font.FontFamilies, font.Size, font.Variant, font.Weight, font.Stretch, font.Style, font.LineHeight });
}
protected override Boolean IsValid(ICssValue value)
{
return(Converter.TryConvert(value, m =>
{
_topWidth.TrySetValue(m.Item1);
_topStyle.TrySetValue(m.Item2);
_topColor.TrySetValue(m.Item3);
_leftWidth.TrySetValue(m.Item1);
_leftStyle.TrySetValue(m.Item2);
_leftColor.TrySetValue(m.Item3);
_rightWidth.TrySetValue(m.Item1);
_rightStyle.TrySetValue(m.Item2);
_rightColor.TrySetValue(m.Item3);
_bottomWidth.TrySetValue(m.Item1);
_bottomStyle.TrySetValue(m.Item2);
_bottomColor.TrySetValue(m.Item3);
}));
}
public static Length?ToBorderSlice(this ICssValue value)
{
var percent = value.ToPercent();
if (percent.HasValue)
{
return(new Length(percent.Value.Value, Length.Unit.Percent));
}
var number = value.ToSingle();
if (number.HasValue)
{
return(new Length(number.Value, Length.Unit.Px));
}
return(null);
}
public ICssValue Convert(StringSource source)
{
var options = new ICssValue[_converters.Length];
for (var i = 0; i < _converters.Length; i++)
{
var option = _converters[i].Convert(source);
if (option == null)
{
break;
}
source.SkipSpacesAndComments();
options[i] = option;
}
return(new CssTupleValue(options));
}
public ICssValue[] Split(ICssValue value)
{
if (value is CssBackgroundValue background)
{
return(new[]
{
CreateMultiple(background, m => m.Image, InitialValues.BackgroundImageDecl),
CreateMultiple(background, m => m.Position, InitialValues.BackgroundPositionDecl),
CreateMultiple(background, m => m.Size, InitialValues.BackgroundSizeDecl),
CreateMultiple(background, m => m.Repeat, InitialValues.BackgroundRepeatDecl),
CreateMultiple(background, m => m.Attachment, InitialValues.BackgroundAttachmentDecl),
CreateMultiple(background, m => m.Origin, InitialValues.BackgroundOriginDecl),
CreateMultiple(background, m => m.Clip, InitialValues.BackgroundClipDecl),
background.Color,
});
}
return(null);
}
public Boolean Validate(ICssValue value)
{
var items = value as CssValueList;
if (items == null || items.Length != _arguments)
{
return(false);
}
for (int i = 0; i < _arguments; i++)
{
if (!_converter.Validate(items[i]))
{
return(false);
}
}
return(true);
}
public ICssValue Merge(ICssValue[] values)
{
var x = values[0] as CssListValue;
var y = values[1] as CssListValue;
if (x != null && y != null && x.Items.Length == y.Items.Length)
{
var points = new ICssValue[x.Items.Length];
for (var i = 0; i < points.Length; i++)
{
points[i] = new Point(x.Items[i], y.Items[i]);
}
return(new CssListValue(points));
}
return(null);
}
public ICssValue Merge(ICssValue[] values)
{
var h = values[0] as CssListValue;
var v = values[1] as CssListValue;
if (h != null && v != null && h.Items.Length == v.Items.Length)
{
var repeats = new ICssValue[h.Items.Length];
for (var i = 0; i < repeats.Length; i++)
{
repeats[i] = new CssImageRepeatsValue(h.Items[i], v.Items[i]);
}
return(new CssListValue(repeats));
}
return(null);
}
public ICssValue[] Split(ICssValue value)
{
if (value is CssListValue list)
{
return(new[]
{
CreateMultiple(list, 0),
CreateMultiple(list, 1),
CreateMultiple(list, 2),
CreateMultiple(list, 3),
CreateMultiple(list, 4),
CreateMultiple(list, 5),
CreateMultiple(list, 6),
CreateMultiple(list, 7),
});
}
return(null);
}
public static Length?ToDistance(this ICssValue value)
{
var percent = value as Percent?;
if (percent == null)
{
var number = value as Number?;
if (number.HasValue && number.Value == Number.Zero)
{
return(Length.Zero);
}
}
else
{
return(new Length(percent.Value.Value, Length.Unit.Percent));
}
return(value as Length?);
}
/// <summary>
/// Tries to set the given value.
/// </summary>
/// <param name="value">The value that should be used.</param>
/// <returns>True if the given value is accepted, otherwise false.</returns>
internal Boolean TrySetValue(ICssValue value)
{
var result = false;
if (value == null)
{
result = !IsMinimum && !IsMaximum && TrySetDefault();
}
else
{
result = TrySetCustom(value);
}
if (result)
{
_value = value;
}
return(result);
}
public Boolean Validate(ICssValue value)
{
var values = value as CssValueList;
var end = default(ICssValue);
if (values != null)
{
var items = values.ToList();
end = items[items.Count - 1].Reduce();
items.RemoveAt(items.Count - 1);
values = new CssValueList(items.Select(m => m.Reduce()).ToList());
}
else
{
values = new CssValueList();
end = value;
}
return(_endConverter.Validate(end) && (values.Length == 0 || _listConverter.Validate(values)));
}
/// <summary>
/// Determines if the given value represents a valid state of this property.
/// </summary>
/// <param name="value">The state that should be used.</param>
/// <returns>True if the state is valid, otherwise false.</returns>
protected override Boolean IsValid(ICssValue value)
{
//[ <bg-layer> , ]* <final-bg-layer> where:
// <bg-layer> =
// <bg-image> || <position> [ / <bg-size> ]? || <repeat-style> || <attachment> || <box> || <box>
// <final-bg-layer> =
// <bg-image> || <position> [ / <bg-size> ]? || <repeat-style> || <attachment> || <box> || <box> || <background-color>
return(Converter.TryConvert(value, m =>
{
_image.TrySetValue(Transform(m, n => n.Item1));
_position.TrySetValue(Transform(m, n => n.Item2.Item1));
_size.TrySetValue(Transform(m, n => n.Item2.Item2));
_repeat.TrySetValue(Transform(m, n => n.Item3));
_attachment.TrySetValue(Transform(m, n => n.Item4));
_origin.TrySetValue(Transform(m, n => n.Item5));
_clip.TrySetValue(Transform(m, n => n.Item6));
_color.TrySetValue(m.Item2.Item7);
}));
}
public override ICssValue GetPropertyCssValue(string propertyName)
{
if (collectedStyles.ContainsKey(propertyName))
{
CssCollectedProperty scp = collectedStyles[propertyName];
if (scp.CssValue.CssValueType == CssValueType.Inherit)
{
// get style from parent chain
return(getParentStyle(propertyName));
}
else
{
return(scp.CssValue.GetAbsoluteValue(propertyName, _element));
}
}
else
{
// should this property inherit?
CssXmlDocument doc = (CssXmlDocument)_element.OwnerDocument;
if (doc.CssPropertyProfile.IsInheritable(propertyName))
{
ICssValue parValue = getParentStyle(propertyName);
if (parValue != null)
{
return(parValue);
}
}
string initValue = doc.CssPropertyProfile.GetInitialValue(propertyName);
if (initValue == null)
{
return(null);
}
else
{
return(CssValue.GetCssValue(initValue, false).GetAbsoluteValue(propertyName, _element));
}
}
}
private static ICssValue CreateValue(CssListValue duration, CssListValue timing, CssListValue delay, CssListValue iterationCount, CssListValue direction, CssListValue fillMode, CssListValue playState, CssListValue name)
{
var items = (duration ?? timing ?? delay ?? iterationCount ?? direction ?? fillMode ?? playState ?? name).Items;
var layers = new ICssValue[items.Length];
for (var i = 0; i < items.Length; i++)
{
layers[i] = new CssTupleValue(new[]
{
GetValue(duration, i),
GetValue(timing, i),
GetValue(delay, i),
GetValue(iterationCount, i),
GetValue(direction, i),
GetValue(fillMode, i),
GetValue(playState, i),
GetValue(name, i),
});
}
return(new CssListValue(layers));
}
public Boolean TryConvert(ICssValue value, Action <T[]> setResult)
{
var items = value.AsEnumeration().ToArray();
if (items.Length < _minimum || items.Length > _maximum)
{
return(false);
}
var targets = new T[items.Length];
for (var i = 0; i < items.Length; i++)
{
if (!_converter.TryConvert(items[i], nv => targets[i] = nv))
{
return(false);
}
}
setResult(targets);
return(true);
}
public Boolean TryConvert(ICssValue value, Action <T[]> setResult)
{
var items = value as CssValueList;
if (items == null || items.Length != _arguments)
{
return(false);
}
var array = new T[_arguments];
for (int i = 0; i < _arguments; i++)
{
if (!_converter.TryConvert(items[i], m => array[i] = m))
{
return(false);
}
}
setResult(array);
return(true);
}
public static Length?ToLineHeight(this ICssValue value)
{
var distance = value.ToDistance();
if (distance != null)
{
return(distance);
}
else if (value.Is(Keywords.Normal))
{
return(new Length(120f, Length.Unit.Percent));
}
var val = value.ToSingle();
if (val.HasValue)
{
return(new Length(val.Value * 100f, Length.Unit.Percent));
}
return(null);
}
public Boolean TryConvert(ICssValue value, Action <Tuple <T[], U> > setResult)
{
var values = value as CssValueList;
var end = default(ICssValue);
if (values != null)
{
var items = values.ToList();
end = items[items.Count - 1].Reduce();
items.RemoveAt(items.Count - 1);
values = items.ToSeparatedList();
}
else
{
values = new CssValueList();
end = value;
}
T[] v1 = default(T[]);
U v2 = default(U);
if (!_endConverter.TryConvert(end, m => v2 = m))
{
return(false);
}
if (values.Length != 0 && !_listConverter.TryConvert(values, m => v1 = m))
{
return(false);
}
else if (values.Length == 0)
{
v1 = new T[0];
}
setResult(Tuple.Create(v1, v2));
return(true);
}
public static GradientStop?ToGradientStop(ICssValue value, Length?location)
{
var values = value as CssValueList;
var color = Color.Transparent;
if (values != null)
{
if (values.Length != 2)
{
return(null);
}
location = values[1].ToDistance();
value = values[0];
}
if (!Converters.ColorConverter.TryConvert(value, m => color = m) || location == null)
{
return(null);
}
return(new GradientStop(color, location.Value));
}
