public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
if (!string.IsNullOrEmpty(value))
{
int x, y;
var thickness = value.Split(',');
foreach (var thick in thickness)
{
if (null != NodeILExtensions.GetDPValueSubFix(thick))
{
return(null);
}
}
if (int.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) &&
int.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out y))
{
return(GenerateIL(module, x, y));
}
}
throw new XamlParseException($"Cannot convert \"{value}\" into Size2D", node);
}
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
if (string.IsNullOrEmpty(value))
{
throw new XamlParseException($"Cannot convert \"{value}\" into Rectangle", node);
}
double x, y, w, h;
var xywh = value.Split(',');
foreach (var thick in xywh)
{
if (null != NodeILExtensions.GetDPValueSubFix(thick))
{
return(null);
}
}
if (xywh.Length != 4 ||
!double.TryParse(xywh [0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) ||
!double.TryParse(xywh [1], NumberStyles.Number, CultureInfo.InvariantCulture, out y) ||
!double.TryParse(xywh [2], NumberStyles.Number, CultureInfo.InvariantCulture, out w) ||
!double.TryParse(xywh [3], NumberStyles.Number, CultureInfo.InvariantCulture, out h))
{
throw new XamlParseException($"Cannot convert \"{value}\" into Rectangle", node);
}
return(GenerateIL(x, y, w, h, module));
}
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
if (string.IsNullOrEmpty(value))
{
throw new XamlParseException($"Cannot convert \"{value}\" into Rectangle", node);
}
double x = -1, y = -1, w = -1, h = -1;
bool hasX, hasY, hasW, hasH;
var xywh = value.Split(',');
foreach (var thick in xywh)
{
if (null != NodeILExtensions.GetDPValueSubFix(thick))
{
return(null);
}
}
if (xywh.Length != 2 && xywh.Length != 4)
{
throw new XamlParseException($"Cannot convert \"{value}\" into Rectangle", node);
}
hasX = (xywh.Length == 2 || xywh.Length == 4) && double.TryParse(xywh [0], NumberStyles.Number, CultureInfo.InvariantCulture, out x);
hasY = (xywh.Length == 2 || xywh.Length == 4) && double.TryParse(xywh [1], NumberStyles.Number, CultureInfo.InvariantCulture, out y);
hasW = xywh.Length == 4 && double.TryParse(xywh [2], NumberStyles.Number, CultureInfo.InvariantCulture, out w);
hasH = xywh.Length == 4 && double.TryParse(xywh [3], NumberStyles.Number, CultureInfo.InvariantCulture, out h);
if (!hasW && xywh.Length == 4 && string.Compare("AutoSize", xywh [2].Trim(), StringComparison.OrdinalIgnoreCase) == 0)
{
hasW = true;
//w = AbsoluteLayout.AutoSize;
}
if (!hasH && xywh.Length == 4 && string.Compare("AutoSize", xywh [3].Trim(), StringComparison.OrdinalIgnoreCase) == 0)
{
hasH = true;
//h = AbsoluteLayout.AutoSize;
}
if (hasX && hasY && xywh.Length == 2)
{
hasW = true;
//w = AbsoluteLayout.AutoSize;
hasH = true;
//h = AbsoluteLayout.AutoSize;
}
if (!hasX || !hasY || !hasW || !hasH)
{
throw new XamlParseException($"Cannot convert \"{value}\" into Rectangle", node);
}
return(GenerateIL(x, y, w, h, module));
}
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
var thickness = value.Split(',');
foreach (var thick in thickness)
{
if (null != NodeILExtensions.GetDPValueSubFix(thick))
{
return(null);
}
}
if (3 == thickness.Length)
{
double x, y, z;
if (double.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) &&
double.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out y) &&
double.TryParse(thickness[2], NumberStyles.Number, CultureInfo.InvariantCulture, out z))
{
return(GenerateIL(module, x, y, z));
}
}
else if (2 == thickness.Length)
{
double x, y;
if (double.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) &&
double.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out y))
{
return(GenerateIL(module, x, y, 0));
}
}
else if (1 == thickness.Length)
{
if (value.Contains("."))
{
string[] parts = value.Split('.');
if (parts.Length == 2 && (parts[0].Trim() == "ParentOrigin" || parts[0].Trim() == "PivotPoint"))
{
string position = parts[parts.Length - 1].Trim();
return(ConvertToPoint(position, context, node));
}
}
else
{
return(ConvertToPoint(value, context, node));
}
}
throw new XamlParseException($"Cannot convert \"{value}\" into Position", node);
}
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
if (!string.IsNullOrEmpty(value))
{
double l, t, r, b;
var thickness = value.Split(',');
foreach (var thick in thickness)
{
if (null != NodeILExtensions.GetDPValueSubFix(thick))
{
return(null);
}
}
switch (thickness.Length)
{
case 1:
if (double.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out l))
{
return(GenerateIL(module, l));
}
break;
case 2:
if (double.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out l) &&
double.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out t))
{
return(GenerateIL(module, l, t));
}
break;
case 4:
if (double.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out l) &&
double.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out t) &&
double.TryParse(thickness[2], NumberStyles.Number, CultureInfo.InvariantCulture, out r) &&
double.TryParse(thickness[3], NumberStyles.Number, CultureInfo.InvariantCulture, out b))
{
return(GenerateIL(module, l, t, r, b));
}
break;
}
}
throw new XamlParseException($"Cannot convert \"{value}\" into Thickness", node);
}
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node)
{
var module = context.Body.Method.Module;
if (!string.IsNullOrEmpty(value))
{
var thickness = value.Split(',');
foreach (var thick in thickness)
{
if (null != NodeILExtensions.GetDPValueSubFix(thick))
{
return(null);
}
}
if (4 == thickness.Length)
{
ushort start, end, top, bottom;
if (ushort.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out start) &&
ushort.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out end) &&
ushort.TryParse(thickness[2], NumberStyles.Number, CultureInfo.InvariantCulture, out top) &&
ushort.TryParse(thickness[2], NumberStyles.Number, CultureInfo.InvariantCulture, out bottom))
{
return(GenerateIL(module, start, end, top, bottom));
}
}
else if (1 == thickness.Length)
{
ushort v;
ushort.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out v);
return(GenerateIL(module, v, v, v, v));
}
}
throw new XamlParseException($"Cannot convert \"{value}\" into Position", node);
}
public void Visit(ElementNode node, INode parentNode)
{
var typeref = Module.ImportReference(node.XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, Module, node));
if (IsXaml2009LanguagePrimitive(node))
{
var vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
var value = GetValueFromLanguagePrimitive(typeref, node);
Context.Values[node] = value;
return;
}
TypeDefinition typedef = typeref.ResolveCached();
//if this is a MarkupExtension that can be compiled directly, compile and returns the value
var compiledMarkupExtensionName = typeref
.GetCustomAttribute(Module, (XamlTask.xamlAssemblyName, XamlTask.xamlNameSpace, "ProvideCompiledAttribute"))
?.ConstructorArguments?[0].Value as string;
Type compiledMarkupExtensionType;
ICompiledMarkupExtension markupProvider;
if (compiledMarkupExtensionName != null &&
(compiledMarkupExtensionType = Type.GetType(compiledMarkupExtensionName)) != null &&
(markupProvider = Activator.CreateInstance(compiledMarkupExtensionType) as ICompiledMarkupExtension) != null)
{
Context.Values[node] = markupProvider.ProvideValue(node, Module, Context);
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
//clean the node as it has been fully exhausted
foreach (var prop in node.Properties)
{
if (!node.SkipProperties.Contains(prop.Key))
{
node.SkipProperties.Add(prop.Key);
}
}
node.CollectionItems.Clear();
return;
}
MethodDefinition factoryCtorInfo = null;
MethodDefinition factoryMethodInfo = null;
MethodDefinition parameterizedCtorInfo = null;
MethodDefinition ctorInfo = null;
if (node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
factoryCtorInfo = typedef.AllMethods().FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.MatchXArguments(node, typeref, Module, Context));
if (factoryCtorInfo == null)
{
throw new XamlParseException(
string.Format("No constructors found for {0} with matching x:Arguments", typedef.FullName), node);
}
ctorInfo = factoryCtorInfo;
if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params
{
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
var argumentList = GetCtorXArguments(node, factoryCtorInfo.Parameters.Count, true);
Context.Values[node] = new EXamlCreateObject(Context, null, typedef, argumentList.ToArray());
return;
}
}
else if (node.Properties.ContainsKey(XmlName.xFactoryMethod))
{
var factoryMethod = (string)(node.Properties[XmlName.xFactoryMethod] as ValueNode).Value;
factoryMethodInfo = typedef.AllMethods().FirstOrDefault(md => !md.IsConstructor &&
md.Name == factoryMethod &&
md.IsStatic &&
md.MatchXArguments(node, typeref, Module, Context));
if (factoryMethodInfo == null)
{
var typeExtensionRef = Module.ImportReference(node.XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.OnlyGetTypeExtension, Module, node));
typeExtensionRef = typeExtensionRef?.ResolveCached();
if (null != typeExtensionRef)
{
factoryMethodInfo = typeExtensionRef.ResolveCached().AllMethods().FirstOrDefault(md => !md.IsConstructor &&
md.Name == factoryMethod &&
md.IsStatic &&
md.MatchXArguments(node, typeExtensionRef, Module, Context));
}
}
if (factoryMethodInfo == null)
{
throw new XamlParseException(
String.Format("No static method found for {0}::{1} ({2})", typedef.FullName, factoryMethod, null), node);
}
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
var argumentList = GetCtorXArguments(node, factoryMethodInfo.Parameters.Count, false);
Context.Values[node] = new EXamlCreateObject(Context, null, typedef, factoryMethodInfo, argumentList?.ToArray());
return;
}
if (ctorInfo == null && factoryMethodInfo == null)
{
parameterizedCtorInfo = typedef.Methods.FirstOrDefault(md => md.IsConstructor &&
!md.IsStatic &&
md.HasParameters &&
md.Parameters.All(
pd =>
pd.CustomAttributes.Any(
ca =>
ca.AttributeType.FullName ==
"Tizen.NUI.Binding.ParameterAttribute")));
}
string missingCtorParameter = null;
List <object> parameterizedCtorParams = null;
if (parameterizedCtorInfo != null && ValidateCtorArguments(parameterizedCtorInfo, node, out missingCtorParameter))
{
ctorInfo = parameterizedCtorInfo;
parameterizedCtorParams = GetCtorArguments(parameterizedCtorInfo, node, Context);
//Fang
//IL_0000: ldstr "foo"
//Context.IL.Append(PushCtorArguments(parameterizedCtorInfo, node));
}
ctorInfo = ctorInfo ?? typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters && !md.IsStatic);
if (null == ctorInfo)
{
foreach (var method in typedef.Methods)
{
if (method.IsConstructor && !method.IsStatic)
{
bool areAllParamsDefault = true;
foreach (var param in method.Parameters)
{
if (!param.HasDefault)
{
areAllParamsDefault = false;
break;
}
}
if (areAllParamsDefault)
{
if (null == ctorInfo)
{
ctorInfo = method;
}
else
{
throw new XamlParseException($"{typedef.FullName} has more than one constructor which params are all default.", node);
}
}
}
}
if (null == ctorInfo && !typedef.IsValueType)
{
throw new XamlParseException($"{typedef.FullName} has no constructor which params are all default.", node);
}
}
if (parameterizedCtorInfo != null && ctorInfo == null)
{
//there was a parameterized ctor, we didn't use it
throw new XamlParseException($"The Property '{missingCtorParameter}' is required to create a '{typedef.FullName}' object.", node);
}
var ctorinforef = ctorInfo?.ResolveGenericParameters(typeref, Module);
var factorymethodinforef = factoryMethodInfo?.ResolveGenericParameters(typeref, Module);
var implicitOperatorref = typedef.Methods.FirstOrDefault(md =>
md.IsPublic &&
md.IsStatic &&
md.IsSpecialName &&
md.Name == "op_Implicit" && md.Parameters[0].ParameterType.FullName == "System.String");
if (ctorinforef != null || factorymethodinforef != null || typedef.IsValueType)
{
VariableDefinition vardef = new VariableDefinition(typeref);
Context.Variables[node] = vardef;
ValueNode vnode = null;
if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
vardef.VariableType.IsValueType)
{
Context.Values[node] = vnode.GetBaseValue(Context, typeref);
}
else if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null &&
implicitOperatorref != null)
{
var converterType = vnode.GetConverterType(new ICustomAttributeProvider[] { typeref.ResolveCached() });
if (null == converterType)
{
var realValue = vnode.GetBaseValue(Context, typeref);
Context.Values[node] = new EXamlCreateObject(Context, realValue, typeref);
}
else
{
var converterValue = new EXamlValueConverterFromString(Context, converterType.Resolve(), vnode.Value as string);
Context.Values[node] = new EXamlCreateObject(Context, converterValue, typeref);
}
}
else if (factorymethodinforef != null)
{
//Fang
//Context.IL.Emit(OpCodes.Call, Module.ImportReference(factorymethodinforef));
//Context.IL.Emit(OpCodes.Stloc, vardef);
}
else if (!typedef.IsValueType)
{
var ctor = Module.ImportReference(ctorinforef);
//IL_0001: newobj instance void class [Tizen.NUI.Xaml.UIComponents]Tizen.NUI.Xaml.UIComponents.Button::'.ctor'()
//IL_0006: stloc.0
//Context.IL.Emit(OpCodes.Newobj, ctor);
//Context.IL.Emit(OpCodes.Stloc, vardef);
if (typeref.FullName == "Tizen.NUI.Xaml.ArrayExtension")
{
typeref = Module.ImportReference(typeof(ArrayExtension));
}
var accordingType = this.GetType().Assembly.GetType(typeref.FullName);
if (null != accordingType && accordingType != typeof(Binding.Setter) && accordingType != typeof(ResourceDictionary))
{
Context.Values[node] = new EXamlCreateObject(Context, Activator.CreateInstance(accordingType), typeref);
}
else if (null != parameterizedCtorParams)
{
Context.Values[node] = new EXamlCreateObject(Context, null, typeref, parameterizedCtorParams.ToArray());
}
else
{
bool canConvertCollectionItem = false;
if (!typeref.InheritsFromOrImplements(Context.Module.ImportReference(typeof(List <string>)).Resolve())
&&
node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null)
{
var valueNode = node.CollectionItems.First() as ValueNode;
if (valueNode.CanConvertValue(Context.Module, typeref, (TypeReference)null))
{
var converterType = valueNode.GetConverterType(new ICustomAttributeProvider[] { typeref.Resolve() });
if (null != converterType)
{
var converterValue = new EXamlValueConverterFromString(Context, converterType.Resolve(), valueNode.Value as string);
Context.Values[node] = new EXamlCreateObject(Context, converterValue, typeref);
}
else
{
var valueItem = valueNode.GetBaseValue(Context, typeref);
if (null == valueItem)
{
throw new XamlParseException($"Can't convert collection item \"{vnode.Value}\" to object", node);
}
Context.Values[node] = valueItem;
}
canConvertCollectionItem = true;
}
}
if (false == canConvertCollectionItem)
{
if (!ctorInfo.HasParameters)
{
Context.Values[node] = new EXamlCreateObject(Context, null, typeref);
}
else
{
object[] @params = new object[ctorInfo.Parameters.Count];
for (int i = 0; i < ctorInfo.Parameters.Count; i++)
{
var param = ctorInfo.Parameters[i];
if (ctorInfo.Parameters[i].ParameterType.ResolveCached().IsEnum)
{
@params[i] = NodeILExtensions.GetParsedEnum(Context, param.ParameterType, param.Constant.ToString());
}
else
{
@params[i] = param.Constant;
}
}
Context.Values[node] = new EXamlCreateObject(Context, null, typeref, @params);
}
}
}
}
else if (ctorInfo != null && node.Properties.ContainsKey(XmlName.xArguments) &&
!node.Properties.ContainsKey(XmlName.xFactoryMethod) && ctorInfo.MatchXArguments(node, typeref, Module, Context))
{
var argumentList = GetCtorXArguments(node, factoryCtorInfo.Parameters.Count, true);
Context.Values[node] = new EXamlCreateObject(Context, null, typedef, argumentList.ToArray());
return;
}
else
{
Context.Values[node] = new EXamlCreateObject(Context, null, typedef, null);
return;
}
if (typeref.FullName == "Tizen.NUI.Xaml.ArrayExtension")
{
//Fang
//var visitor = new SetPropertiesVisitor(Context);
//foreach (var cnode in node.Properties.Values.ToList())
// cnode.Accept(visitor, node);
//foreach (var cnode in node.CollectionItems)
// cnode.Accept(visitor, node);
//markupProvider = new ArrayExtension();
//var il = markupProvider.ProvideValue(node, Module, Context, out typeref);
//vardef = new VariableDefinition(typeref);
//Context.Variables[node] = vardef;
//Context.Body.Variables.Add(vardef);
//Context.IL.Append(il);
//Context.IL.Emit(OpCodes.Stloc, vardef);
////clean the node as it has been fully exhausted
//foreach (var prop in node.Properties)
// if (!node.SkipProperties.Contains(prop.Key))
// node.SkipProperties.Add(prop.Key);
//node.CollectionItems.Clear();
return;
}
}
}
