using Tizen.NUI.EXaml;
using Mono.Cecil;
using Tizen.NUI.EXaml.Build.Tasks;
+using Tizen.NUI.Xaml.Build.Tasks;
namespace Tizen.NUI.Xaml
{
[AcceptEmptyServiceProvider]
internal sealed class BindingExtension : IMarkupExtension<BindingBase>
{
+ public XmlType XmlType { get; set; }
public string Path { get; set; } = Tizen.NUI.Binding.Binding.SelfPath;
public BindingMode Mode { get; set; } = BindingMode.Default;
{
if (TypedBinding == null)
{
- var newTypeRef = module.ImportReference(typeof(Tizen.NUI.Binding.Binding));
- return new EXamlCreateObject(context, null, newTypeRef, new object[] { Path, ModeInEXaml, Converter, ConverterParameter, StringFormat, Source });
+ var typeRef = XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.OnlyGetType, module, null);
+ return new EXamlCreateObject(context, null, typeRef, new object[] { Path, ModeInEXaml, Converter, ConverterParameter, StringFormat, Source });
}
else
{
string ret = String.Format("({0} ({1} {2}))\n",
eXamlContext.GetValueString((int)EXamlOperationType.CreateArrayObject),
- eXamlContext.GetValueString(eXamlContext.GetTypeIndex(Type)),
+ eXamlContext.GetValueString(eXamlContext.GetTypeIndex(Type.Resolve())),
itemsString);
return ret;
public EXamlCreateObject(EXamlContext context, object instance, TypeReference type, object[] @params = null)
: base(context)
{
- if (null == type?.Resolve())
- {
- throw new Exception("Type can't be null when create object");
- }
-
Instance = instance;
Type = type;
public void Visit(ElementNode node, INode parentNode)
{
- var typeref = Module.ImportReference(node.XmlType.GetTypeReference(Module, node));
+ var typeref = Module.ImportReference(node.XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, Module, node));
if (IsXaml2009LanguagePrimitive(node))
{
if (factoryMethodInfo == null)
{
- var typeExtensionRef = Module.ImportReference(node.XmlType.GetTypeExtensionReference(Module, node));
+ var typeExtensionRef = Module.ImportReference(node.XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.OnlyGetTypeExtension, Module, node));
typeExtensionRef = typeExtensionRef?.ResolveCached();
if (null != typeExtensionRef)
if (typeref.FullName == "Tizen.NUI.Xaml.ArrayExtension")
{
typeref = Module.ImportReference(typeof(ArrayExtension));
- typedef = typeref.ResolveCached();
}
- var accordingType = this.GetType().Assembly.GetType(typedef.FullName);
+ var accordingType = this.GetType().Assembly.GetType(typeref.FullName);
if (null != accordingType && accordingType != typeof(Binding.Setter))
{
case "System.TimeSpan":
if (hasValue && TimeSpan.TryParse(valueString, CultureInfo.InvariantCulture, out TimeSpan outspan))
{
-
ret = outspan;
}
else
if ("System.Type" == valueType.FullName)
{
- var typeRef = XmlTypeExtensions.GetTypeReference(valueNode.Value as string, Module, node as BaseNode);
+ var typeRef = XmlTypeExtensions.GetTypeReference(valueNode.Value as string, Module, node as BaseNode, XmlTypeExtensions.ModeOfGetType.Both);
context.Values[node] = new EXamlCreateObject(context, typeRef);
}
else
try
{
type = new XmlType(namespaceuri, name + "Extension", null);
- type.GetTypeReference(contextProvider.Context.Module, null);
+ type.GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, contextProvider.Context.Module, null);
}
catch (XamlParseException)
{
public bool IsResourceDictionary(ElementNode node)
{
var parentVar = Context.Values[node] as EXamlCreateObject;
- return null != parentVar
- &&
- (parentVar.GetType().FullName == "Tizen.NUI.Binding.ResourceDictionary"
- || parentVar.GetType().Resolve().BaseType?.FullName == "Tizen.NUI.Binding.ResourceDictionary");
+
+ if (null != parentVar && !parentVar.GetType().IsLocalType())
+ {
+ return parentVar.GetType().FullName == "Tizen.NUI.Binding.ResourceDictionary"
+ ||
+ parentVar.GetType().Resolve().BaseType?.FullName == "Tizen.NUI.Binding.ResourceDictionary";
+ }
+
+ return false;
}
ModuleDefinition Module { get; }
internal static string GetContentProperty(TypeReference typeRef)
{
- var typeDef = typeRef.ResolveCached();
- var attributes = typeDef.CustomAttributes;
- var attr =
- attributes.FirstOrDefault(cad => ContentPropertyAttribute.ContentPropertyTypes.Contains(cad.AttributeType.FullName));
- if (attr != null)
- return attr.ConstructorArguments[0].Value as string;
- if (typeDef.BaseType == null)
- return null;
- return GetContentProperty(typeDef.BaseType);
+ if (typeRef.IsLocalType())
+ {
+ return typeRef.GetContentPropertyNameOfLocalType();
+ }
+ else
+ {
+ var typeDef = typeRef.ResolveCached();
+ var attributes = typeDef.CustomAttributes;
+ var attr =
+ attributes.FirstOrDefault(cad => ContentPropertyAttribute.ContentPropertyTypes.Contains(cad.AttributeType.FullName));
+ if (attr != null)
+ return attr.ConstructorArguments[0].Value as string;
+ if (typeDef.BaseType == null)
+ return null;
+ return GetContentProperty(typeDef.BaseType);
+ }
}
public static object ProvideValue(EXamlCreateObject instance, EXamlContext context,
else if (instance.GetType().ImplementsGenericInterface("Tizen.NUI.Xaml.IMarkupExtension`1", out markupExtension, out genericArguments))
{
var nodeValue = context.Values[node] as EXamlCreateObject;
- if (nodeValue?.Instance is BindingExtension)
+ if (nodeValue?.Instance is BindingExtension bindingExtension)
{
- var newValue = (nodeValue.Instance as BindingExtension).ProvideValue(context, module);
+ bindingExtension.XmlType = new XmlType(node.XmlType.NamespaceUri, "Binding", node.XmlType.TypeArguments);
+ var newValue = bindingExtension.ProvideValue(context, module);
return newValue;
}
else if (nodeValue?.Instance is DynamicResourceExtension)
return properties;
}
+ private static bool SetPropertyValueToLocalType(EXamlCreateObject parent, XmlName propertyName, INode valueNode, EXamlContext context)
+ {
+ if (parent.Instance is Tizen.NUI.Xaml.Build.Tasks.ArrayExtension arrayExtension)
+ {
+ if ("Type" == propertyName.LocalName)
+ {
+ var value = context.Values[valueNode] as EXamlCreateObject;
+ if (null != value)
+ {
+ arrayExtension.Type = value.Instance as TypeReference;
+ parent.IsValid = false;
+ }
+ }
+ else if ("Items" == propertyName.LocalName)
+ {
+ arrayExtension.Items = context.Values[valueNode];
+ parent.IsValid = false;
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
public static void SetPropertyValue(EXamlCreateObject parent, XmlName propertyName, INode valueNode, EXamlContext context, IXmlLineInfo iXmlLineInfo)
{
var module = context.Module;
var localName = propertyName.LocalName;
bool attached;
+ if (SetPropertyValueToLocalType(parent, propertyName, valueNode, context))
+ {
+ return;
+ }
+
var bpRef = GetBindablePropertyReference(parent, propertyName.NamespaceURI, ref localName, out attached, context, iXmlLineInfo);
//If the target is an event, connect
if (implicitOperator != null)
return true;
- return valueInstance.GetType().InheritsFromOrImplements(XamlTask.bindingNameSpace + ".BindingBase");
+ return valueInstance.GetType().InheritsFromOrImplements(module.ImportReference((XamlCTask.bindingAssemblyName, XamlCTask.bindingNameSpace, "BindingBase")));
}
static void SetBinding(EXamlCreateObject parent, MemberReference bpRef, IElementNode elementNode, IXmlLineInfo iXmlLineInfo, EXamlContext context)
{
return true;
}
+
+ if ("System.Type" == valueTypeRef.FullName && "Mono.Cecil.TypeReference" == propertyType.FullName)
+ {
+ return true;
+ }
}
return false;
static Dictionary<EXamlCreateObject, IList<string>> resourceNamesInUse = new Dictionary<EXamlCreateObject, IList<string>>();
static bool CanAddToResourceDictionary(EXamlCreateObject parent, TypeReference collectionType, IElementNode node, IXmlLineInfo lineInfo, EXamlContext context)
{
+ if (collectionType.IsLocalType())
+ {
+ return false;
+ }
+
if ( collectionType.FullName != "Tizen.NUI.Binding.ResourceDictionary"
&& collectionType.ResolveCached().BaseType?.FullName != "Tizen.NUI.Binding.ResourceDictionary")
return false;
{
var typename = localname.Substring(0, dotIdx);
localname = localname.Substring(dotIdx + 1);
- elementType = new XmlType(namespaceURI, typename, null).GetTypeReference(context.Module, lineInfo);
+ elementType = new XmlType(namespaceURI, typename, null).GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, context.Module, lineInfo);
return true;
}
return false;
static void SetDataTemplate(ElementNode parentNode, ElementNode rootnode, EXamlContext parentContext,
IXmlLineInfo xmlLineInfo)
{
- var typeref = parentContext.Module.ImportReference(rootnode.XmlType.GetTypeReference(parentContext.Module, rootnode));
+ var typeref = parentContext.Module.ImportReference(rootnode.XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, parentContext.Module, rootnode));
var visitorContext = new EXamlContext(typeref.ResolveCached(), typeref.Module);
rootnode.Accept(new XamlNodeVisitor((node, parent) => node.Parent = parent), null);
var eXamlString = visitorContext.GenerateEXamlString();
- var parentTyperef = parentContext.Module.ImportReference(parentNode.XmlType.GetTypeReference(parentContext.Module, parentNode));
+ var parentTyperef = parentContext.Module.ImportReference(parentNode.XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, parentContext.Module, parentNode));
if (parentContext.Values[parentNode] is EXamlCreateObject eXamlObject)
{
{
return typeReference1 == typeReference2;
}
+ else if (typeReference1.IsArray || typeReference2.IsArray)
+ {
+ if (typeReference1.IsArray != typeReference2.IsArray)
+ {
+ return false;
+ }
+ else
+ {
+ return typeReference1.Resolve() == typeReference2.Resolve();
+ }
+ }
else if (typeReference1.Resolve() != typeReference2.Resolve())
{
return false;
return false;
}
}
-
else
{
return true;
if (typeName == null || propertyName == null)
throw new XamlParseException($"Cannot convert \"{value}\" into {typeof(BindableProperty)}", node);
- var typeRef = XmlTypeExtensions.GetTypeReference(typeName, module, node);
+ var typeRef = XmlTypeExtensions.GetTypeReference(typeName, module, node, XmlTypeExtensions.ModeOfGetType.Both);
if (typeRef == null)
throw new XamlParseException($"Can't resolve {typeName}", node);
bpRef = GetBindablePropertyFieldReference(typeRef, propertyName, module);
else
xmlType = new XmlType(node.NamespaceResolver.LookupNamespace(""), split[0], null);
- var typeRef = xmlType.GetTypeReference(module, (IXmlLineInfo)node, true);
+ var typeRef = xmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, module, (IXmlLineInfo)node, true);
if (typeRef == null)
goto error;
var typename = member.Substring(0, dotIdx);
var membername = member.Substring(dotIdx + 1);
- var typeRef = module.ImportReference(XmlTypeExtensions.GetTypeReference(typename, module, node as BaseNode));
+ var typeRef = module.ImportReference(XmlTypeExtensions.GetTypeReference(typename, module, node as BaseNode, XmlTypeExtensions.ModeOfGetType.Both));
var fieldRef = GetFieldReference(typeRef, membername, module);
var propertyDef = GetPropertyDefinition(typeRef, membername, module);
var typename = member.Substring(0, dotIdx);
var membername = member.Substring(dotIdx + 1);
- var typeRef = module.ImportReference(XmlTypeExtensions.GetTypeReference(typename, module, node as BaseNode));
+ var typeRef = module.ImportReference(XmlTypeExtensions.GetTypeReference(typename, module, node as BaseNode, XmlTypeExtensions.ModeOfGetType.Both));
var fieldRef = GetFieldReference(typeRef, membername, module);
var propertyDef = GetPropertyDefinition(typeRef, membername, module);
node.CollectionItems.Clear();
}
- var typeref = module.ImportReference(XmlTypeExtensions.GetTypeReference(valueNode.Value as string, module, node as BaseNode));
+ var typeref = module.ImportReference(XmlTypeExtensions.GetTypeReference(valueNode.Value as string, module, node as BaseNode, XmlTypeExtensions.ModeOfGetType.Both));
context.TypeExtensions[node] = typeref ?? throw new XamlParseException($"Can't resolve type `{valueNode.Value}'.", node as IXmlLineInfo);
node.CollectionItems.Clear();
}
- var typeref = module.ImportReference(XmlTypeExtensions.GetTypeReference(valueNode.Value as string, module, node as BaseNode));
+ var typeref = module.ImportReference(XmlTypeExtensions.GetTypeReference(valueNode.Value as string, module, node as BaseNode, XmlTypeExtensions.ModeOfGetType.Both));
context.TypeExtensions[node] = typeref ?? throw new XamlParseException($"Can't resolve type `{valueNode.Value}'.", node as IXmlLineInfo);
- return new EXamlCreateObject(context, typeref, module.ImportReference(typeof(TypeReference)));
+ return new EXamlCreateObject(context, typeref, module.ImportReference(typeof(System.Type))) { IsValid = false,};
}
}
}
public void Visit(ElementNode node, INode parentNode)
{
- var typeref = Module.ImportReference(node.XmlType.GetTypeReference(Module, node));
+ var typeref = Module.ImportReference(node.XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, Module, node));
TypeDefinition typedef = typeref.ResolveCached();
if (IsXaml2009LanguagePrimitive(node))
md.MatchXArguments(node, typeref, Module, Context));
if (factoryMethodInfo == null)
{
- var typeExtensionRef = Module.ImportReference(node.XmlType.GetTypeExtensionReference(Module, node));
+ var typeExtensionRef = Module.ImportReference(node.XmlType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.OnlyGetTypeExtension, Module, node));
typeExtensionRef = typeExtensionRef?.ResolveCached();
if (null != typeExtensionRef?.Resolve())
foreach (var prop in node.Properties)
if (!node.SkipProperties.Contains(prop.Key))
node.SkipProperties.Add(prop.Key);
- node.CollectionItems.Clear();
return;
}
try
{
type = new XmlType(namespaceuri, name + "Extension", null);
- type.GetTypeReference(contextProvider.Context.Module, null);
+ type.GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, contextProvider.Context.Module, null);
}
catch (XamlParseException)
{
bool isAdded = false;
- if (CanAddToResourceDictionary(parentVar, parentVar.VariableType, node, node, Context))
+ if (parentVar.VariableType.IsArray)
+ {
+ isAdded = true;
+ }
+ else if (CanAddToResourceDictionary(parentVar, parentVar.VariableType, node, node, Context))
{
Context.IL.Emit(Ldloc, parentVar);
Context.IL.Append(AddToResourceDictionary(node, node, Context));
var dtXType = new XmlType(namespaceuri, dataType, null);
- var tSourceRef = dtXType.GetTypeReference(module, (IXmlLineInfo)node);
+ var tSourceRef = dtXType.GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, module, (IXmlLineInfo)node);
if (tSourceRef == null)
yield break; //throw
{
var typename = localname.Substring(0, dotIdx);
localname = localname.Substring(dotIdx + 1);
- elementType = new XmlType(namespaceURI, typename, null).GetTypeReference(context.Body.Method.Module, lineInfo);
+ elementType = new XmlType(namespaceURI, typename, null).GetTypeReference(XmlTypeExtensions.ModeOfGetType.Both, context.Body.Method.Module, lineInfo);
return true;
}
return false;
{
return true;
}
+ else if (typeRef.IsLocalType())
+ {
+ //Avoid to resolve the type reference of XamlBuild
+ return false;
+ }
else
{
var typeDef = typeRef.ResolveCached();
public static IEnumerable<Tuple<MethodDefinition, TypeReference>> GetMethods(this TypeReference typeRef,
Func<MethodDefinition, TypeReference, bool> predicate, ModuleDefinition module)
{
+ if (typeRef.IsLocalType())
+ {
+ yield break;
+ }
+
var typeDef = typeRef.ResolveCached();
foreach (var method in typeDef.Methods.Where(md => predicate(md, typeRef)))
yield return new Tuple<MethodDefinition, TypeReference>(method, typeRef);
return self.GetElementType().MakeGenericInstanceType(args.ToArray());
}
+ public static string GetContentPropertyNameOfLocalType(this TypeReference typeReference)
+ {
+ if ("Tizen.NUI.Xaml.Build.Tasks.ArrayExtension" == typeReference.FullName)
+ {
+ return "Items";
+ }
+
+ return null;
+ }
+
+ public static bool IsLocalType(this TypeReference typeReference)
+ {
+ if ("Tizen.NUI.Xaml.Build.Tasks.ArrayExtension" == typeReference.FullName)
+ {
+ return true;
+ }
+
+ return false;
+ }
+
static Dictionary<TypeReference, TypeDefinition> resolves = new Dictionary<TypeReference, TypeDefinition>();
public static TypeDefinition ResolveCached(this TypeReference typeReference)
{
if (null != e.StackTrace)
{
- LoggingHelper.LogMessage(Low, e.StackTrace);
+ LoggingHelper.LogError(e.StackTrace);
}
return false;
{
static class XmlTypeExtensions
{
+ internal enum ModeOfGetType
+ {
+ OnlyGetType,
+ OnlyGetTypeExtension,
+ Both
+ }
+
static internal IList<XmlnsDefinitionAttribute> s_xmlnsDefinitions;
static void GatherXmlnsDefinitionAttributes()
{
//this could be extended to look for [XmlnsDefinition] in all assemblies
- s_xmlnsDefinitions = XamlTask.s_xmlnsDefinitions.OrderByDescending(a => a.Level).ToList(); ;
+ s_xmlnsDefinitions = XamlTask.s_xmlnsDefinitions.OrderByDescending(a => a.Level).ToList();
}
- public static TypeReference GetTypeReference(string xmlType, ModuleDefinition module, BaseNode node)
+ public static TypeReference GetTypeReference(string xmlType, ModuleDefinition module, BaseNode node, ModeOfGetType mode)
{
var split = xmlType.Split(':');
if (split.Length > 2)
name = split[0];
}
var namespaceuri = node.NamespaceResolver.LookupNamespace(prefix) ?? "";
- return GetTypeReference(new XmlType(namespaceuri, name, null), module, node as IXmlLineInfo);
+ return GetTypeReference(new XmlType(namespaceuri, name, null), mode, module, node as IXmlLineInfo);
}
- public static TypeReference GetTypeReference(string namespaceURI, string typename, ModuleDefinition module, IXmlLineInfo xmlInfo)
+ public static TypeReference GetTypeReference(string namespaceURI, string typename, ModuleDefinition module, IXmlLineInfo xmlInfo, ModeOfGetType info)
{
- return new XmlType(namespaceURI, typename, null).GetTypeReference(module, xmlInfo);
+ return new XmlType(namespaceURI, typename, null).GetTypeReference(info, module, xmlInfo);
}
- public static TypeReference GetTypeReference(this XmlType xmlType, ModuleDefinition module, IXmlLineInfo xmlInfo, bool fromAllAssembly = false)
+ public static TypeReference GetTypeReference(this XmlType xmlType, ModeOfGetType mode, ModuleDefinition module, IXmlLineInfo xmlInfo, bool fromAllAssembly = false)
{
if (s_xmlnsDefinitions == null)
GatherXmlnsDefinitionAttributes();
});
}
- lookupNames.Add(elementName);
- lookupNames.Add(elementName + "Extension");
-
- for (var i = 0; i < lookupNames.Count; i++)
- {
- var name = lookupNames[i];
- if (name.Contains(":"))
- name = name.Substring(name.LastIndexOf(':') + 1);
- if (typeArguments != null)
- name += "`" + typeArguments.Count; //this will return an open generic Type
- lookupNames[i] = name;
- }
-
- TypeReference type = null;
- foreach (var asm in lookupAssemblies)
+ switch (mode)
{
- if (type != null)
+ case ModeOfGetType.OnlyGetType:
+ lookupNames.Add(elementName);
break;
- foreach (var name in lookupNames)
- {
- if (type != null)
- break;
-
- var clrNamespace = asm.ClrNamespace;
- var typeName = name.Replace('+', '/'); //Nested types
- var idx = typeName.LastIndexOf('.');
- if (idx >= 0) {
- clrNamespace += '.' + typeName.Substring(0, typeName.LastIndexOf('.'));
- typeName = typeName.Substring(typeName.LastIndexOf('.') + 1);
- }
- type = module.GetTypeDefinition((asm.AssemblyName, clrNamespace, typeName));
- }
- }
-
- if (type != null && typeArguments != null && type.HasGenericParameters)
- {
- type =
- module.ImportReference(type)
- .MakeGenericInstanceType(typeArguments.Select(x => GetTypeReference(x, module, xmlInfo)).ToArray());
- }
-
- if (type == null)
- throw new XamlParseException(string.Format("Type {0} not found in xmlns {1}", elementName, namespaceURI), xmlInfo);
-
- return module.ImportReference(type);
- }
-
- public static TypeReference GetTypeExtensionReference(this XmlType xmlType, ModuleDefinition module, IXmlLineInfo xmlInfo, bool fromAllAssembly = false)
- {
- if (s_xmlnsDefinitions == null)
- GatherXmlnsDefinitionAttributes();
-
- var namespaceURI = xmlType.NamespaceUri;
- var elementName = xmlType.Name;
- var typeArguments = xmlType.TypeArguments;
-
- if (elementName.Contains("-"))
- {
- elementName = elementName.Replace('-', '+');
- }
-
- var lookupAssemblies = new List<XmlnsDefinitionAttribute>();
- var lookupNames = new List<string>();
-
- if (true == fromAllAssembly)
- {
- foreach (var xmlnsDef in s_xmlnsDefinitions)
- {
- lookupAssemblies.Add(xmlnsDef);
- }
- }
- else
- {
- foreach (var xmlnsDef in s_xmlnsDefinitions)
- {
- if (xmlnsDef.XmlNamespace != namespaceURI)
- continue;
- lookupAssemblies.Add(xmlnsDef);
- }
- }
-
- if (lookupAssemblies.Count == 0)
- {
- string ns;
- string typename;
- string asmstring;
- string targetPlatform;
+ case ModeOfGetType.OnlyGetTypeExtension:
+ lookupNames.Add(elementName + "Extension");
+ break;
- XmlnsHelper.ParseXmlns(namespaceURI, out typename, out ns, out asmstring, out targetPlatform);
- asmstring = asmstring ?? module.Assembly.Name.Name;
- if (ns != null)
- lookupAssemblies.Add(new XmlnsDefinitionAttribute(namespaceURI, ns, 0)
- {
- AssemblyName = asmstring
- });
+ case ModeOfGetType.Both:
+ lookupNames.Add(elementName);
+ lookupNames.Add(elementName + "Extension");
+ break;
}
- lookupNames.Add(elementName + "Extension");
-
for (var i = 0; i < lookupNames.Count; i++)
{
var name = lookupNames[i];
var clrNamespace = asm.ClrNamespace;
var typeName = name.Replace('+', '/'); //Nested types
var idx = typeName.LastIndexOf('.');
- if (idx >= 0)
- {
+ if (idx >= 0) {
clrNamespace += '.' + typeName.Substring(0, typeName.LastIndexOf('.'));
typeName = typeName.Substring(typeName.LastIndexOf('.') + 1);
}
type = module.GetTypeDefinition((asm.AssemblyName, clrNamespace, typeName));
-
- if (null == type)
- {
- type = module.GetTypeDefinition((module.Assembly.Name.Name, clrNamespace, typeName));
- }
}
}
{
type =
module.ImportReference(type)
- .MakeGenericInstanceType(typeArguments.Select(x => GetTypeReference(x, module, xmlInfo)).ToArray());
+ .MakeGenericInstanceType(typeArguments.Select(x => GetTypeReference(x, mode, module, xmlInfo)).ToArray());
}
if (type == null)
public void Do()
{
- var type = globalDataList.GatheredTypes[typeIndex];
- var array = Array.CreateInstance(type, null == items ? 0 : items.Count);
+ var type = typeIndex < 0 ? GetBaseType.GetBaseTypeByIndex(typeIndex) : globalDataList.GatheredTypes[typeIndex];
+ IList array = Array.CreateInstance(type, null == items ? 0 : items.Count);
if (null != items)
{
{
if (items[i] is Instance instance)
{
- ((IList)array)[i] = globalDataList.GatheredInstances[instance.Index];
+ array[i] = globalDataList.GatheredInstances[instance.Index];
+ }
+ else
+ {
+ array[i] = items[i];
}
}
}
InitializeComponent();
// FIXME: For now, menuItem1, 2, 3, 4 handles are not found by FindByName.
- /*
+
menuItem1.Clicked += MenuItem1Clicked;
menuItem2.Clicked += MenuItem2Clicked;
menuItem3.Clicked += MenuItem3Clicked;
menuItem4.Clicked += MenuItem4Clicked;
- */
}
private void MenuItem1Clicked(object sender, ClickedEventArgs args)
<Folder Include="lib\" />
</ItemGroup>
-
- <ItemGroup>
- <PackageReference Include="Tizen.NUI.XamlBuild" Version="1.0.32" />
- </ItemGroup>
-
<ItemGroup>
<ProjectReference Include="../../src/Tizen.NUI.Components/Tizen.NUI.Components.csproj" />
<ProjectReference Include="../../src/Tizen.NUI/Tizen.NUI.csproj" />
</ItemGroup>
<PropertyGroup>
- <NeedInjection>False</NeedInjection>
+ <XamlOptimization>2</XamlOptimization>
</PropertyGroup>
+ <ImportGroup>
+ <Import Project="..\..\pkg\Tizen.NET.API10\xamlbuild\Tizen.NUI.XamlBuild.targets" />
+ </ImportGroup>
</Project>
projects / platform / core / csapi / tizenfx.git / commitdiff