Stetic.ClassDescriptor FindType(TypeDefinition cls)
{
if (cls.BaseType == null)
{
return(null);
}
string baseTypeFullName = cls.BaseType.FullName;
if (cls.BaseType.IsGenericInstance)
{
baseTypeFullName = baseTypeFullName.Substring(0, baseTypeFullName.IndexOf('<'));
}
Stetic.ClassDescriptor klass = Stetic.Registry.LookupClassByName(baseTypeFullName);
if (klass != null)
{
return(klass);
}
TypeDefinition bcls = FindTypeDefinition(baseTypeFullName);
if (bcls == null)
{
return(null);
}
return(FindType(bcls));
}
protected override ClassDescriptor LoadClassDescriptor(XmlElement element)
{
string name = element.GetAttribute("type");
TypeDefinition cls = null;
Stetic.ClassDescriptor typeClassDescriptor = null;
string tname;
if (element.HasAttribute("baseClassType"))
{
tname = element.GetAttribute("baseClassType");
typeClassDescriptor = Stetic.Registry.LookupClassByName(tname);
}
else
{
cls = assembly.MainModule.GetType(name);
if (cls != null)
{
// Find the nearest type that can be loaded
typeClassDescriptor = FindType(assembly, cls);
tname = cls.Name;
if (typeClassDescriptor != null)
{
element.SetAttribute("baseClassType", typeClassDescriptor.Name);
objects_dirty = true;
}
}
}
if (typeClassDescriptor == null)
{
Console.WriteLine("Descriptor not found: " + name);
return(null);
}
XmlElement steticDefinition = null;
XmlDocument gui = cache [filename].GuiDocument;
if (gui != null)
{
string wrappedTypeName = element.GetAttribute("type");
steticDefinition = (XmlElement)gui.DocumentElement.SelectSingleNode("widget[@id='" + wrappedTypeName + "']");
}
CecilClassDescriptor cd = new CecilClassDescriptor(this, element, typeClassDescriptor, steticDefinition, cls);
if (canGenerateCode && !cd.CanGenerateCode)
{
canGenerateCode = false;
}
return(cd);
}
public CecilPropertyDescriptor(XmlElement elem, Stetic.ItemGroup group, Stetic.ClassDescriptor klass, PropertyDescriptor prop) : base(elem, group, klass)
{
this.name = prop.Name;
this.type = prop.PropertyType;
this.canWrite = prop.CanWrite;
if (type.IsValueType)
{
initialValue = Activator.CreateInstance(type);
}
this.label = prop.Label;
this.description = prop.Description;
this.maximum = prop.Maximum;
this.minimum = prop.Minimum;
this.initWithName = prop.InitWithName;
this.translatable = prop.Translatable;
}
Stetic.ClassDescriptor FindType(AssemblyDefinition asm, TypeDefinition cls)
{
if (cls.BaseType == null)
{
return(null);
}
Stetic.ClassDescriptor klass = Stetic.Registry.LookupClassByName(cls.BaseType.FullName);
if (klass != null)
{
return(klass);
}
TypeDefinition bcls = FindTypeDefinition(cls.BaseType.FullName);
if (bcls == null)
{
return(null);
}
return(FindType(asm, bcls));
}
public CecilPropertyDescriptor(CecilWidgetLibrary lib, XmlElement elem, Stetic.ItemGroup group, Stetic.ClassDescriptor klass, PropertyDefinition pinfo) : base(elem, group, klass)
{
string tname;
if (pinfo != null)
{
name = pinfo.Name;
tname = pinfo.PropertyType.FullName;
canWrite = pinfo.SetMethod != null;
}
else
{
name = elem.GetAttribute("name");
tname = elem.GetAttribute("type");
canWrite = elem.Attributes ["canWrite"] == null;
}
Load(elem);
type = Stetic.Registry.GetType(tname, false);
if (type == null)
{
Console.WriteLine("Could not find type: " + tname);
type = typeof(string);
}
if (type.IsValueType)
{
initialValue = Activator.CreateInstance(type);
}
// Consider all properties runtime-properties, since they have been created
// from class properties.
isRuntimeProperty = true;
if (pinfo != null)
{
SaveCecilXml(elem);
}
}
public CecilSignalDescriptor(CecilWidgetLibrary lib, XmlElement elem, Stetic.ItemGroup group, Stetic.ClassDescriptor klass, EventDefinition sinfo) : base(elem, group, klass)
{
if (sinfo != null)
{
string handler = sinfo.EventType.FullName;
handlerTypeName = handler.Replace('/', '+');
Type t = Registry.GetType(handler, false);
if (t != null)
{
MethodInfo mi = t.GetMethod("Invoke");
handlerReturnTypeName = mi.ReturnType.FullName;
ParameterInfo[] pars = mi.GetParameters();
handlerParameters = new ParameterDescriptor [pars.Length];
for (int n = 0; n < pars.Length; n++)
{
handlerParameters [n] = new ParameterDescriptor(pars[n].Name, pars[n].ParameterType.FullName);
}
}
else
{
// If the type is generic, the type arguments must be ignored when looking for the type
string tn = handler;
int i = handler.IndexOf('<');
if (i != -1)
{
tn = handler.Substring(0, i);
// Convert the type name to a type reference
handler = handler.Replace('<', '[');
handler = handler.Replace('>', ']');
}
TypeDefinition td = lib.FindTypeDefinition(tn);
if (td != null)
{
MethodDefinition mi = null;
foreach (MethodDefinition md in td.Methods)
{
if (md.Name == "Invoke")
{
mi = md;
break;
}
}
if (mi != null)
{
handlerReturnTypeName = CecilWidgetLibrary.GetInstanceType(td, sinfo.EventType, mi.ReturnType.ReturnType);
handlerParameters = new ParameterDescriptor [mi.Parameters.Count];
for (int n = 0; n < handlerParameters.Length; n++)
{
ParameterDefinition par = mi.Parameters [n];
handlerParameters [n] = new ParameterDescriptor(par.Name, CecilWidgetLibrary.GetInstanceType(td, sinfo.EventType, par.ParameterType));
}
}
}
else
{
handlerParameters = new ParameterDescriptor [0];
}
}
SaveCecilXml(elem);
}
else
{
handlerTypeName = elem.GetAttribute("handlerTypeName");
handlerReturnTypeName = elem.GetAttribute("handlerReturnTypeName");
ArrayList list = new ArrayList();
foreach (XmlNode npar in elem.ChildNodes)
{
XmlElement epar = npar as XmlElement;
if (epar == null)
{
continue;
}
list.Add(new ParameterDescriptor(epar.GetAttribute("name"), epar.GetAttribute("type")));
}
handlerParameters = (ParameterDescriptor[])list.ToArray(typeof(ParameterDescriptor));
}
Load(elem);
}
