internal CSSPrimitiveValue(CSSColor value)
{
_text = value.ToCss();
_type = CssValueType.PrimitiveValue;
_unit = CssUnit.Rgbcolor;
_value = value;
}
/// <summary>
/// Cria uma nova instancia de <see cref="Thickness"/>.
/// </summary>
/// <param name="top">Valor da coordenada superior.</param>
/// <param name="right">Valor da coordenada direita.</param>
/// <param name="bottom">Valor da coordenada inferior.</param>
/// <param name="left">Valor da coordenada esquerda.</param>
/// <param name="unit">Unidade css a ser utilizada.</param>
public Thickness(int? top, int? right, int? bottom, int? left, CssUnit unit = CssUnit.Px)
{
Top = top;
Bottom = bottom;
Left = left;
Right = right;
Unit = unit;
}
internal CssValuePairList SetPairListValue()
{
var value = new CssValuePairList();
mUnit = CssUnit.PairList;
mValue = value;
return(value);
}
/// <summary>
/// Cria uma nova instancia de <see cref="Thickness"/>.
/// </summary>
/// <param name="top">Valor da coordenada superior.</param>
/// <param name="right">Valor da coordenada direita.</param>
/// <param name="bottom">Valor da coordenada inferior.</param>
/// <param name="left">Valor da coordenada esquerda.</param>
/// <param name="unit">Unidade css a ser utilizada.</param>
public Thickness(int?top, int?right, int?bottom, int?left, CssUnit unit = CssUnit.Px)
{
Top = top;
Bottom = bottom;
Left = left;
Right = right;
Unit = unit;
}
internal CssRect SetRectValue()
{
var value = new CssRect();
mUnit = CssUnit.Rect;
mValue = value;
return(value);
}
public void CssDimensionTest(string dimensionStr,
double expectedNumber,
CssUnit expectedUnit)
{
var cssDim = new CssDimension(dimensionStr);
Assert.AreEqual(cssDim.Number, expectedNumber);
Assert.AreEqual(cssDim.UnitOfMeasurement, expectedUnit);
}
internal CssValue(CssValue[] aValue, CssUnit aUnit)
{
mUnit = aUnit;
mValue = aValue;
if (UnitHasArrayValue() && mValue != null)
{
return;
}
mUnit = CssUnit.Null;
mValue = null;
}
internal CssValue(string aValue, CssUnit aUnit)
{
mUnit = aUnit;
mValue = aValue;
if (UnitHasStringValue() && mValue != null)
{
return;
}
mUnit = CssUnit.Null;
mValue = null;
}
internal CssValue(float aValue, CssUnit aUnit)
{
mUnit = aUnit;
mValue = aValue;
if (aUnit >= CssUnit.Percent)
{
return;
}
mUnit = CssUnit.Null;
mValue = null;
}
internal CssValue(int32_t aValue, CssUnit aUnit)
{
mUnit = aUnit;
mValue = aValue;
if (aUnit == CssUnit.Integer || aUnit == CssUnit.Enumerated || aUnit == CssUnit.EnumColor)
{
return;
}
mUnit = CssUnit.Null;
mValue = null;
}
/// <summary>
/// AddUnit: It is used to Add Unit to Database
/// </summary>
public int AddUnit(CssUnit model)
{
try
{
var result = _context.Unit.Add(model);
_context.SaveChanges();
return(result.Entity.Code);
}
catch (Exception ex)
{
return(0);
}
}
/// <summary>
/// UpdateUnit: It is used to Update Unit
/// </summary>
public bool UpdateUnit(CssUnit model)
{
try
{
var result = _context.Unit.Update(model);
_context.SaveChanges();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public static string GetAbbreviation(this CssUnit unit)
{
switch (unit)
{
case CssUnit.Pixels:
return("px");
case CssUnit.Percent:
return("%");
default:
throw new InvalidOperationException("Unknown unit: " + unit);
}
}
/// <summary>
/// Gets the primitive value's number if any.
/// </summary>
/// <param name="unit">The unit of the number.</param>
/// <returns>The value of the number if any.</returns>
public Single? GetFloatValue(CssUnit unit)
{
if (_value is Single)
{
var qty = (Single)_value;
//TODO Convert
switch (unit)
{
case CssUnit.Percentage:
qty = qty / 100f;
break;
}
return qty;
}
return null;
}
public CssNumericValue(string value, CssUnit unit)
{
Value = value;
Unit = unit;
}
internal void Reset()
{
mUnit = CssUnit.Null;
mValue = null;
}
internal CSSPrimitiveValue(CssUnit unit, String value)
{
_type = CssValueType.PrimitiveValue;
SetStringValue(unit, value);
}
internal CSSPrimitiveValue(CssUnit unit, Single value)
{
_type = CssValueType.PrimitiveValue;
SetFloatValue(unit, value);
}
public static T SetMarginUnit <T>(this T control, CssUnit unit) where T : HtmlControl
{
control.MarginUnit = unit;
return(control);
}
/// <summary>
/// Sets the primitive value to the given number.
/// </summary>
/// <param name="unit">The unit of the number.</param>
/// <param name="value">The value of the number.</param>
/// <returns>The CSS primitive value instance.</returns>
public CSSPrimitiveValue SetFloatValue(CssUnit unit, Single value)
{
_text = value.ToString(CultureInfo.InvariantCulture) + ConvertUnitTypeToString(unit);
_unit = unit;
_value = value;
return this;
}
/// <summary>
/// Cria uma nova instancia de <see cref="Thickness"/>.
/// </summary>
/// <param name="all">Valor que será atribuído a todas coordenadas.</param>
/// <param name="unit">Unidade a ser utilizada.</param>
public Thickness(int all, CssUnit unit = CssUnit.Px)
{
Top = Bottom = Left = Right = all;
Unit = unit;
}
/// <summary>
/// Cria uma nova instancia de <see cref="Thickness"/>.
/// </summary>
/// <param name="v">Valor a ser atribuido às propriedades Top e Bottom</param>
/// <param name="h">Valor a ser atribuido às propriedades Left e Right</param>
/// <param name="unit">Unidade a ser utilizada.</param>
public Thickness(int v, int? h, CssUnit unit = CssUnit.Px)
{
Top = Bottom = v;
Left = Right = h;
Unit = unit;
}
/// <summary>
/// Atribui o mesmo valor a todas as coordenadas.
/// </summary>
/// <param name="all">Valor a ser atribuido.</param>
/// <param name="unit">Unidade a ser utilizada.</param>
public void All(int all, CssUnit unit = CssUnit.Px)
{
Top = Bottom = Left = Right = all;
Unit = unit;
}
/// <summary>
/// Cria uma nova instancia de <see cref="Thickness"/> com todos os valores nulos.
/// </summary>
/// <param name="unit">Unidade css a utilizar</param>
public Thickness(CssUnit unit = CssUnit.Px)
{
Unit = unit;
}
public IActionResult Unit(CssUnit model)
{
return(View());
}
public CssNumericValue(int value, CssUnit unit) : this(value.ToString(), unit)
{
}
public CssNumericValue(CssUnit unit)
{
Unit = unit;
}
public CssNumericValue(int value, CssUnit unit) : this(value.ToString(), unit)
{
}
public float MergeMultiplicativeR(CssUnit aCalcFunction, float aValue1, float aValue2)
{
Debug.Assert(aCalcFunction == CssUnit.CalcTimesR || aCalcFunction == CssUnit.CalcDivided, "unexpected unit");
return(aCalcFunction == CssUnit.CalcTimesR ? aValue1 * aValue2 : aValue1 / aValue2);
}
public CssNumericValue(string value, CssUnit unit)
{
Value = value;
Unit = unit;
}
public CssValue(int value, CssUnit unit = CssUnit.px)
{
Unit = unit;
StringValue = default;
NumberValue = value;
}
public static T SetPaddingUnit <T>(this T control, CssUnit unit) where T : HtmlControl
{
control.PaddingUnit = unit;
return(control);
}
public float MergeMultiplicativeL(CssUnit aCalcFunction, float aValue1, float aValue2)
{
Debug.Assert(aCalcFunction == CssUnit.CalcTimesL, "unexpected unit");
return(aValue1 * aValue2);
}
/// <summary>
/// Sets the primitive value to the given string.
/// </summary>
/// <param name="unit">The unit of the string.</param>
/// <param name="value">The value of the string.</param>
/// <returns>The CSS primitive value instance.</returns>
public CSSPrimitiveValue SetStringValue(CssUnit unit, String value)
{
switch (unit)
{
case CssUnit.String:
_text = "'" + value + "'";
break;
case CssUnit.Uri:
_text = "url('" + value + "')";
break;
default:
_text = value;
break;
}
_unit = unit;
_value = value;
return this;
}
/// <summary>
/// Cria uma nova instancia de <see cref="Thickness"/>.
/// </summary>
/// <param name="all">Valor que será atribuído a todas coordenadas.</param>
/// <param name="unit">Unidade a ser utilizada.</param>
public Thickness(int all, CssUnit unit = CssUnit.Px)
{
Top = Bottom = Left = Right = all;
Unit = unit;
}
internal static String ConvertUnitTypeToString(CssUnit unit)
{
switch (unit)
{
case CssUnit.Percentage: return "%";
case CssUnit.Ems: return "em";
case CssUnit.Cm: return "cm";
case CssUnit.Deg: return "deg";
case CssUnit.Grad: return "grad";
case CssUnit.Rad: return "rad";
case CssUnit.Turn: return "turn";
case CssUnit.Exs: return "ex";
case CssUnit.Hz: return "hz";
case CssUnit.In: return "in";
case CssUnit.Khz: return "khz";
case CssUnit.Mm: return "mm";
case CssUnit.Ms: return "ms";
case CssUnit.S: return "s";
case CssUnit.Pc: return "pc";
case CssUnit.Pt: return "pt";
case CssUnit.Px: return "px";
case CssUnit.Vw: return "vw";
case CssUnit.Vh: return "vh";
case CssUnit.Vmin: return "vmin";
case CssUnit.Vmax: return "vmax";
}
return String.Empty;
}
/// <summary>
/// Cria uma nova instancia de <see cref="Thickness"/>.
/// </summary>
/// <param name="v">Valor a ser atribuido às propriedades Top e Bottom</param>
/// <param name="h">Valor a ser atribuido às propriedades Left e Right</param>
/// <param name="unit">Unidade a ser utilizada.</param>
public Thickness(int v, int?h, CssUnit unit = CssUnit.Px)
{
Top = Bottom = v;
Left = Right = h;
Unit = unit;
}
/*union {
* int32_t mInt;
* float mFloat;
* nsStringBuffer* mString;
* nscolor mColor;
* Array* mArray;
* mozilla::css::URLValue* mURL;
* mozilla::css::ImageValue* mImage;
* nsCSSValueGradient* mGradient;
* nsCSSValuePair_heap* mPair;
* nsCSSRect_heap* mRect;
* nsCSSValueTriplet_heap* mTriplet;
* nsCSSValueList_heap* mList;
* nsCSSValueList* mListDependent;
* nsCSSValuePairList_heap* mPairList;
* nsCSSValuePairList* mPairListDependent;
* } mValue;*/
internal CssValue(CssUnit aUnit)
{
mUnit = aUnit;
mValue = null;
}
internal CssValue(CssValue aValue)
{
mUnit = aValue.mUnit;
mValue = aValue.mValue;
}
/// <summary>
/// Creates a new CssLength from a length specified on a CSS style sheet or fragment
/// </summary>
/// <param name="length">Length as specified in the Style Sheet or style fragment</param>
public CssLength(string length)
{
_length = length;
_number = 0f;
_unit = CssUnit.None;
_isPercentage = false;
//Return zero if no length specified, zero specified
if (string.IsNullOrEmpty(length) || length == "0") return;
//If percentage, use ParseNumber
if (length.EndsWith("%"))
{
_number = CssValue.ParseNumber(length, 1);
_isPercentage = true;
return;
}
//If no units, has error
if (length.Length < 3)
{
float.TryParse(length, out _number);
_hasError = true;
return;
}
//Get units of the length
string u = length.Substring(length.Length - 2, 2);
//Number of the length
string number = length.Substring(0, length.Length - 2);
//TODO: Units behave different in paper and in screen!
switch (u)
{
case CssConstants.Em:
_unit = CssUnit.Ems;
_isRelative = true;
break;
case CssConstants.Ex:
_unit = CssUnit.Ex;
_isRelative = true;
break;
case CssConstants.Px:
_unit = CssUnit.Pixels;
_isRelative = true;
break;
case CssConstants.Mm:
_unit = CssUnit.Milimeters;
break;
case CssConstants.Cm:
_unit = CssUnit.Centimeters;
break;
case CssConstants.In:
_unit = CssUnit.Inches;
break;
case CssConstants.Pt:
_unit = CssUnit.Points;
break;
case CssConstants.Pc:
_unit = CssUnit.Picas;
break;
default:
_hasError = true;
return;
}
if (!float.TryParse(number, System.Globalization.NumberStyles.Number, NumberFormatInfo.InvariantInfo, out _number))
{
_hasError = true;
}
}
public float MergeMultiplicativeL(CssUnit aCalcFunction, float aValue1, float aValue2)
{
Debug.Assert(aCalcFunction == CssUnit.CalcTimesL, "unexpected unit");
return aValue1 * aValue2;
}
internal void SetSystemFontValue()
{
mUnit = CssUnit.SystemFont;
mValue = null;
}
public float MergeMultiplicativeR(CssUnit aCalcFunction, float aValue1, float aValue2)
{
Debug.Assert(aCalcFunction == CssUnit.CalcTimesR || aCalcFunction == CssUnit.CalcDivided, "unexpected unit");
return aCalcFunction == CssUnit.CalcTimesR ? aValue1 * aValue2 : aValue1 / aValue2;
}
public CssNumericValue(CssUnit unit)
{
Unit = unit;
}
public float MergeAdditive(CssUnit aCalcFunction, float aValue1, float aValue2)
{
Debug.Assert(aCalcFunction == CssUnit.CalcPlus || aCalcFunction == CssUnit.CalcMinus, "unexpected unit");
return aCalcFunction == CssUnit.CalcPlus ? aValue1 + aValue2 : aValue1 - aValue2;
}
/// <summary>
/// Cria uma nova instancia de <see cref="Thickness"/> com todos os valores nulos.
/// </summary>
/// <param name="unit">Unidade css a utilizar</param>
public Thickness(CssUnit unit = CssUnit.Px)
{
Unit = unit;
}
public float MergeAdditive(CssUnit aCalcFunction, float aValue1, float aValue2)
{
Debug.Assert(aCalcFunction == CssUnit.CalcPlus || aCalcFunction == CssUnit.CalcMinus, "unexpected unit");
return(aCalcFunction == CssUnit.CalcPlus ? aValue1 + aValue2 : aValue1 - aValue2);
}
/// <summary>
/// Creates a new CssLength from a length specified on a CSS style sheet or fragment
/// </summary>
/// <param name="length">Length as specified in the Style Sheet or style fragment</param>
public CssLength(string length)
{
_length = length;
_number = 0f;
_unit = CssUnit.None;
_isPercentage = false;
//Return zero if no length specified, zero specified
if (string.IsNullOrEmpty(length) || length == "0")
{
return;
}
//If percentage, use ParseNumber
if (length.EndsWith("%"))
{
_number = CssValue.ParseNumber(length, 1);
_isPercentage = true;
return;
}
//If no units, has error
if (length.Length < 3)
{
float.TryParse(length, out _number);
_hasError = true;
return;
}
//Get units of the length
string u = length.Substring(length.Length - 2, 2);
//Number of the length
string number = length.Substring(0, length.Length - 2);
//TODO: Units behave different in paper and in screen!
switch (u)
{
case CssConstants.Em:
_unit = CssUnit.Ems;
_isRelative = true;
break;
case CssConstants.Ex:
_unit = CssUnit.Ex;
_isRelative = true;
break;
case CssConstants.Px:
_unit = CssUnit.Pixels;
_isRelative = true;
break;
case CssConstants.Mm:
_unit = CssUnit.Milimeters;
break;
case CssConstants.Cm:
_unit = CssUnit.Centimeters;
break;
case CssConstants.In:
_unit = CssUnit.Inches;
break;
case CssConstants.Pt:
_unit = CssUnit.Points;
break;
case CssConstants.Pc:
_unit = CssUnit.Picas;
break;
default:
_hasError = true;
return;
}
if (!float.TryParse(number, NumberStyles.Number, NumberFormatInfo.InvariantInfo, out _number))
{
_hasError = true;
}
}
/// <summary>
/// Atribui o mesmo valor a todas as coordenadas.
/// </summary>
/// <param name="all">Valor a ser atribuido.</param>
/// <param name="unit">Unidade a ser utilizada.</param>
public void All(int all, CssUnit unit = CssUnit.Px)
{
Top = Bottom = Left = Right = all;
Unit = unit;
}
