private static void ProcessType (TreeIter parent, System.Type t)
{
foreach (MemberInfo mi in t.GetMembers ()) {
store.AppendValues (parent, mi.Name, mi.ToString ());
count++;
}
}
private void Parse (System.Type aType)
{
object[] attrs;
foreach (MemberInfo info in aType.GetMembers()) {
bool found = false;
attrs = info.GetCustomAttributes (false);
foreach (object attr in attrs) {
if (TypeValidator.IsCompatible(attr.GetType(), typeof(DevelopmentInformationAttribute)) == true) {
members.Add (info);
found = true;
break;
}
}
}
}
internal static MatchType Reflect(System.Type type)
{
MatchType type2 = new MatchType {
type = type
};
MemberInfo[] members = type.GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
ArrayList list = new ArrayList();
for (int i = 0; i < members.Length; i++)
{
MatchMember member = MatchMember.Reflect(members[i]);
if (member != null)
{
list.Add(member);
}
}
type2.fields = (MatchMember[]) list.ToArray(typeof(MatchMember));
return type2;
}
public static AssemblyType CreateAssemblyType(AssemblyImporter importer, System.Type systemType)
{
AssemblyType assemblyType = null;
if (systemType.IsEnum)
{
assemblyType = new AssemblyEnumeration (importer, systemType);
assemblyType.Begin ();
}
else if (systemType.IsInterface)
{
assemblyType = new AssemblyInterface (importer, systemType);
assemblyType.Begin ();
}
else if (systemType.IsClass)
{
assemblyType = new AssemblyClass (importer, systemType);
assemblyType.Begin ();
}
else if (systemType.IsPrimitive)
{
assemblyType = new AssemblyDataType (importer, systemType);
assemblyType.Begin ();
}
else if (systemType.IsValueType)
{
if (systemType.GetMembers (AssemblyHelper.BINDING_FLAGS).Length == 1)
{
assemblyType = new AssemblyDataType (importer, systemType);
assemblyType.Begin ();
}
else
{
assemblyType = new AssemblyStruct (importer, systemType);
assemblyType.Begin ();
}
}
else
{
System.Console.WriteLine ("System.FullName: "+systemType.FullName+" sealed: "+systemType.IsSealed );
}
return assemblyType;
}
private static UiItem[][] getUiItemList(System.Type lType)
{
UiItemUV lOut = new UiItemUV();
var lMembers = lType.GetMembers();
foreach (var lMember in lMembers)
{
UiAttributeBase[] lUIAttributes =
(UiAttributeBase[])lMember.GetCustomAttributes(typeof(UiAttributeBase), false);
foreach (var lAttribute in lUIAttributes)
{
lOut.Add(new UiItem(lAttribute, lMember));
}
//if (lUIAttributes.Length > 0)
//{
// lOut.Add(new UiItem(lUIAttributes[0], lMember));
//}
}
return lOut.toSortedArray();
}
protected virtual void CheckAccessibleMembersAreVirtual(System.Type type)
{
MemberInfo[] members = type.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (var member in members)
{
if (member is PropertyInfo)
{
var property = (PropertyInfo) member;
if(property.ShouldBeProxiable())
{
MethodInfo[] accessors = property.GetAccessors(true);
if (accessors != null)
{
foreach (var accessor in accessors)
{
CheckMethodIsVirtual(type, accessor);
}
}
}
}
else if (member is MethodInfo)
{
var methodInfo = (MethodInfo) member;
// avoid the check of properties getter and setter because already checked when the PropertyInfo was found.
if (!IsPropertyMethod(methodInfo) && methodInfo.ShouldBeProxiable())
{
CheckMethodIsVirtual(type, methodInfo);
}
}
else if (member is FieldInfo)
{
var memberField = (FieldInfo) member;
if (memberField.IsPublic || memberField.IsAssembly || memberField.IsFamilyOrAssembly)
{
EnlistError(type, "field " + member.Name + " should not be public nor internal (ecapsulate it in a property).");
}
}
}
}
protected virtual void CheckAccessibleMembersAreVirtual(System.Type type)
{
MemberInfo[] members = type.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (var member in members)
{
if (member is PropertyInfo)
{
var property = (PropertyInfo) member;
MethodInfo[] accessors = property.GetAccessors(false);
if (accessors != null)
{
foreach (var accessor in accessors)
{
CheckMethodIsVirtual(type, accessor);
}
}
}
else if (member is MethodInfo)
{
if (member.DeclaringType == typeof (object) && member.Name == "GetType")
{
// object.GetType is ignored
continue;
}
CheckMethodIsVirtual(type, (MethodInfo) member);
}
else if (member is FieldInfo)
{
var memberField = (FieldInfo) member;
if (memberField.IsPublic || memberField.IsAssembly || memberField.IsFamilyOrAssembly)
{
EnlistError(type, "field " + member.Name + " should not be public nor internal");
}
}
}
}
PropertyInfo[] createSerializeMethod(System.Type lType, bool pNeedSerializeIn, bool pNeedSerializeOut)
{
List<PropertyInfo> lOut = new List<PropertyInfo>();
var lMembers = lType.GetMembers();
foreach (var lMember in lMembers)
{
zzSerializeAttribute[] lAttributes =
(zzSerializeAttribute[])lMember.GetCustomAttributes(typeof(zzSerializeAttribute), true);
if (lAttributes.Length > 0
&& ( pNeedSerializeIn?lAttributes[0].serializeIn:true)
&& ( pNeedSerializeOut?lAttributes[0].serializeOut:true))
{
lOut.Add((PropertyInfo)lMember);
}
}
return lOut.ToArray();
}
/// <summary>
/// Adds the type to the set of types, and then uses reflection to add
/// all public fields, properties and methods to the set of types.
/// </summary>
protected static void AddAllSubTypes(HashSet<System.Type> typeSet, System.Type t)
{
AddSubType(typeSet, t);
MemberInfo[] memberInfos = t.GetMembers(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly);
foreach (MemberInfo memberInfo in memberInfos)
{
if (memberInfo.MemberType == MemberTypes.Field)
{
FieldInfo fieldInfo = memberInfo as FieldInfo;
AddSubType(typeSet, fieldInfo.FieldType);
}
else if (memberInfo.MemberType == MemberTypes.Property)
{
PropertyInfo propertyInfo = memberInfo as PropertyInfo;
AddSubType(typeSet, propertyInfo.PropertyType);
}
else if (memberInfo.MemberType == MemberTypes.Method)
{
MethodInfo methodInfo = memberInfo as MethodInfo;
if (methodInfo.IsGenericMethod)
{
continue;
}
if (methodInfo.ReturnType != typeof(void))
{
AddSubType(typeSet, methodInfo.ReturnType);
}
foreach (ParameterInfo pi in methodInfo.GetParameters() )
{
AddSubType(typeSet, pi.ParameterType);
}
}
}
}
void ProcessType (DemoTreeNode parent, System.Type t)
{
foreach (MemberInfo mi in t.GetMembers ())
parent.AddChild (new DemoTreeNode (mi.Name, mi.ToString ()));
}
public static IEnumerable<MemberInfo> GetMembers(System.Type tp, bool includeNonPublic)
{
const BindingFlags BINDING = BindingFlags.Public | BindingFlags.Instance;
const BindingFlags PRIV_BINDING = BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly;
const MemberTypes MASK = MemberTypes.Field | MemberTypes.Property | MemberTypes.Method;
if (tp == null) yield break;
foreach (var m in tp.GetMembers(BINDING))
{
if ((m.MemberType & MASK) != 0)
{
yield return m;
}
}
if (includeNonPublic)
{
while (tp != null)
{
foreach (var m in tp.GetMembers(PRIV_BINDING))
{
if ((m.MemberType & MASK) != 0)
{
yield return m;
}
}
tp = tp.BaseType;
}
}
}
private List<string> getComponentMembers( System.Type type )
{
var propertyType = this.getPropertyType();
var members = type
.GetMembers( BindingFlags.Instance | BindingFlags.Public )
.Where( x => x.MemberType == MemberTypes.Field || x.MemberType == MemberTypes.Property );
var list = new List<string>();
foreach( var member in members )
{
System.Type memberType = null;
if( member is FieldInfo )
{
memberType = ( (FieldInfo)member ).FieldType;
}
else
{
var property = (PropertyInfo)member;
if( !property.CanWrite || property.GetSetMethod() == null )
continue;
memberType = property.PropertyType;
}
if( !propertyType.IsAssignableFrom( memberType ) )
continue;
list.Add( string.Format( "{0}.{1}", type.Name, member.Name ) );
}
return list;
}
private static void ProcessType(TreeIter parent, System.Type t)
{
bool iterset = false;
TreeIter iter = TreeIter.Zero;
//if(!(t==typeof(Gtk.Widget) || t.IsSubclassOf(typeof(Gtk.Widget))))
// return;
foreach (MemberInfo mi in t.GetMembers ())
{
// properties
object[] attrs = mi.GetCustomAttributes(typeof(GLib.PropertyAttribute), false);
if(attrs != null && attrs.Length > 0)
{
PropertyInfo prop = (PropertyInfo)mi;
if(prop.DeclaringType != t)
continue;
foreach(GLib.PropertyAttribute attr in attrs)
{
if(!iterset)
{
iterset = true;
iter = store.AppendValues (parent, "<tt><b>"+NiceTypeName(t)+"</b></tt><small>" + Inherits(t)+"</small>", t.ToString()+" : "+t.BaseType.ToString(), t.Name);
}
string rw = ((prop.CanRead)?"r":"") + ((prop.CanWrite)?"w":"");
store.AppendValues (iter,
String.Format("<small>({0})</small>\t<tt><b>{1}</b></tt><small>: {2}</small>",
rw, attr.Name, NiceTypeName(prop.PropertyType)), prop.PropertyType.ToString(), attr.Name);
}
}
// signals
object[] signals = mi.GetCustomAttributes(typeof(GLib.SignalAttribute), false);
if(signals != null && signals.Length > 0)
{
EventInfo ev = (EventInfo)mi;
if(ev.DeclaringType != t)
continue;
foreach(GLib.SignalAttribute signal in signals)
{
if(!iterset)
{
iterset = true;
iter = store.AppendValues (parent, "<tt><b>"+NiceTypeName(t)+"</b></tt><small>" + Inherits(t)+"</small>", t.ToString()+" : "+t.BaseType.ToString(), t.Name);
}
ParameterInfo[] delegateparams = ev.EventHandlerType.GetMethod("Invoke").GetParameters();
string[] evargs = new string[delegateparams.Length];
for(int i=0; i < delegateparams.Length; i++)
{
evargs[i] = NiceTypeName(delegateparams[i].ParameterType)+" "+
delegateparams[i].Name;
}
TreeIter eventiter = store.AppendValues (iter,
String.Format("<small>(sig)</small>\t<tt><b><span foreground=\"#000099\">{0}</span></b></tt><small>{1}</small>",
signal.CName,
/*NiceTypeName(ev.EventHandlerType) +*/ "("+ String.Join(", ", evargs)+")"),
"signal", signal.CName);
WriteEventArgs(eventiter, delegateparams[1].ParameterType);
}
}
}
if(iterset)
{
bool implicit_constructor = false;
bool no_constructor = true;
foreach (MemberInfo mi in t.GetMembers ())
{
if(mi is ConstructorInfo)
{
ConstructorInfo constructor = (ConstructorInfo)mi;
ParameterInfo[] p = constructor.GetParameters();
if(p.Length == 0)
implicit_constructor = true;
if(p.Length == 1 && p[0].ParameterType == typeof(IntPtr))
continue;
no_constructor = false;
string[] ptext = new string[p.Length];
for(int i=0; i<p.Length; i++)
{
ptext[i] = "<small>" + NiceTypeName(p[i].ParameterType) + "</small> <b>" + p[i].Name + "</b>";
}
store.AppendValues (iter, "<small>new</small>\t<tt>(" + String.Join(", ", ptext) + ")</tt>", "konstruktor", "");
}
}
if(implicit_constructor)
store.SetValues(iter, "<tt><b><span foreground=\"#770000\">"+NiceTypeName(t)+"</span></b></tt><small>" + Inherits(t)+"</small>", t.ToString()+" : "+t.BaseType.ToString(), t.Name);
else if(no_constructor)
store.SetValues(iter, "<tt><b><span foreground=\"#999999\">"+NiceTypeName(t)+"</span></b></tt><small>" + Inherits(t)+"</small>", t.ToString()+" : "+t.BaseType.ToString(), t.Name);
}
}
/// <summary>
/// Adds all members to the node's children, grabbing the parameters
/// for methods.
/// </summary>
/// <param name="treeNode"></param>
/// <param name="type"></param>
private void addMembers(TreeNode treeNode, System.Type type)
{
// Get all members except methods
MemberInfo[] memberInfo = type.GetMembers();
for (int j = 0; j < memberInfo.Length; j++)
{
if (memberInfo[j].ReflectedType.IsPublic && memberInfo[j].MemberType != MemberTypes.Method)
{
TreeNode node = treeNode.Nodes.Add(memberInfo[j].Name);
node.Tag = memberInfo[j].MemberType;
}
}
// Get all methods
MethodInfo[] methodInfo = type.GetMethods();
for (int j = 0; j < methodInfo.Length; j++)
{
TreeNode node = treeNode.Nodes.Add(methodInfo[j].Name);
string parms = "";
ParameterInfo[] parameterInfo = methodInfo[j].GetParameters();
for (int f = 0; f < parameterInfo.Length; f++)
{
parms += parameterInfo[f].ParameterType.ToString() + " " + parameterInfo[f].Name + ", ";
}
// Knock off remaining ", "
if (parms.Length > 2)
{
parms = parms.Substring(0, parms.Length - 2);
}
node.Tag = parms;
}
}
private void BeginWithType(System.Type type)
{
if (type.IsEnum)
{
if (Elements [type.FullName] == null && ImportEnumerations)
{
AssemblyEnumeration enm = new AssemblyEnumeration (this, type);
enm.Begin ();
}
}
else if (type.IsInterface)
{
if (Elements [type.FullName] == null && ImportInterfaces)
{
AssemblyInterface intrface = new AssemblyInterface (this, type);
intrface.Begin ();
}
}
else if (type.IsClass)
{
if (Elements [type.FullName] == null && ImportClasses)
{
AssemblyClass cls = new AssemblyClass (this, type);
cls.Begin ();
}
}
else if (type.IsPrimitive)
{
if (Elements [type.FullName] == null)
{
AssemblyDataType dataType = new AssemblyDataType (this, type);
dataType.Begin ();
}
}
else if (type.IsValueType)
{
if (Elements [type.FullName] == null)
{
if (type.GetMembers (AssemblyHelper.BINDING_FLAGS).Length == 1)
{
AssemblyDataType dataType = new AssemblyDataType (this, type);
dataType.Begin ();
}
else if (ImportStructs)
{
AssemblyStruct structure = new AssemblyStruct (this, type);
structure.Begin ();
}
}
}
}
