static public void InvokeCustomSlot(IntPtr obj, string slotname, IntPtr stack, IntPtr ret)
{
QObject qobj = (QObject)((GCHandle)obj).Target;
#if DEBUG
if ((QDebug.DebugChannel() & QtDebugChannel.QTDB_TRANSPARENT_PROXY) != 0)
{
Console.WriteLine("ENTER InvokeCustomSlot() {0}.{1}",
qobj,
slotname);
}
#endif
MethodInfo slot = Qyoto.GetSlotMethodInfo(qobj.GetType(), slotname);
ParameterInfo[] parameters = slot.GetParameters();
object[] args = new object[parameters.Length];
unsafe {
StackItem *stackPtr = (StackItem *)stack;
for (int i = 0; i < args.Length; i++)
{
args[i] = SmokeMarshallers.BoxFromStackItem(parameters[i].ParameterType, 0, stackPtr + i);
}
object returnValue = slot.Invoke(qobj, args);
StackItem *retval = (StackItem *)ret;
if (slot.ReturnType != typeof(void))
{
SmokeMarshallers.UnboxToStackItem(returnValue, retval);
}
}
}
public static int RegisterType <T>()
{
string className;
Destructor dtorHandler;
Constructor ctorHandler;
if (SmokeMarshallers.IsSmokeClass(typeof(T)))
{
className = SmokeMarshallers.SmokeClassName(typeof(T));
dtorHandler = delegate(IntPtr obj) { DestroyObject(className, obj); };
ctorHandler = delegate(IntPtr copy) { return(CreateObject(className, copy)); };
}
else
{
className = typeof(T).ToString();
dtorHandler = delegate(IntPtr obj) { ((GCHandle)obj).Free(); };
ctorHandler = delegate(IntPtr copy) {
if (copy != IntPtr.Zero)
{
object o = (T)((GCHandle)copy).Target; // create a copy if this is a valuetype
return((IntPtr)GCHandle.Alloc(o));
}
return((IntPtr)GCHandle.Alloc(default(T)));
};
}
GCHandle.Alloc(className); // prevent collection
GCHandle.Alloc(dtorHandler);
GCHandle.Alloc(ctorHandler);
return(QMetaTypeRegisterType(className, dtorHandler, ctorHandler));
}
public static T qobject_cast <T>(QObject obj) where T : class
{
if (obj == null)
{
return(null);
}
// direct cast possible?
try {
return((T)(object)obj);
} catch {}
Type t = typeof(T);
if (!SmokeMarshallers.IsSmokeClass(t))
{
return(null);
}
string className = SmokeMarshallers.SmokeClassName(t);
IntPtr ret = qyoto_qt_metacast((IntPtr)GCHandle.Alloc(obj),className);
if (ret == IntPtr.Zero)
{
return(null);
}
else
{
GCHandle handle = (GCHandle)ret;
object target = handle.Target;
handle.Free();
return((T)target);
}
}
public T FindChild <T>(string name)
{
string childClassName = null;
IntPtr metaObject = IntPtr.Zero;
if (SmokeMarshallers.IsSmokeClass(typeof(T)))
{
childClassName = SmokeMarshallers.SmokeClassName(typeof(T));
}
else
{
metaObject = (IntPtr)GCHandle.Alloc(Qyoto.GetMetaObject(typeof(T)));
}
IntPtr child = FindQObjectChild((IntPtr)GCHandle.Alloc(this), childClassName, metaObject, name);
if (child != IntPtr.Zero)
{
try {
return((T)((GCHandle)child).Target);
} catch (Exception e) {
Console.WriteLine("Found child, but an error has occurred: {0}", e.Message);
return(default(T));
}
}
else
{
return(default(T));
}
}
public virtual QMetaObject MetaObject()
{
if (SmokeMarshallers.IsSmokeClass(GetType()))
{
return((QMetaObject)interceptor.Invoke("metaObject", "metaObject()", typeof(QMetaObject), false));
}
else
{
return(Qyoto.GetMetaObject(this));
}
}
public static unsafe void InvokeDelegate(Delegate d, IntPtr stack)
{
MethodInfo mi = d.Method;
ParameterInfo[] parameters = mi.GetParameters();
object[] args = new object[parameters.Length];
StackItem * stackPtr = (StackItem *)stack;
for (int i = 0; i < args.Length; i++)
{
args[i] = SmokeMarshallers.BoxFromStackItem(parameters[i].ParameterType, 0, stackPtr + i);
}
d.DynamicInvoke(args);
}
public override IMessage Invoke(IMessage message)
{
IMethodCallMessage callMessage = (IMethodCallMessage)message;
StackItem[] stack = new StackItem[callMessage.ArgCount + 1];
#if DEBUG
if ((QDebug.DebugChannel() & QtDebugChannel.QTDB_TRANSPARENT_PROXY) != 0)
{
Console.WriteLine("ENTER SignalInvocation.Invoke() MethodName: {0}.{1} Type: {2} ArgCount: {3}",
instance,
callMessage.MethodName,
callMessage.TypeName,
callMessage.ArgCount.ToString());
}
#endif
unsafe
{
fixed(StackItem *stackPtr = stack)
{
for (int i = 0; i < callMessage.ArgCount; i++)
{
SmokeMarshallers.UnboxToStackItem(callMessage.Args[i], stackPtr + i + 1);
}
IMethodReturnMessage returnMessage = new ReturnMessage(null, callMessage); /*(IMethodReturnMessage) message;*/
MethodReturnMessageWrapper returnValue = new MethodReturnMessageWrapper((IMethodReturnMessage)returnMessage);
#if DEBUG
GCHandle instanceHandle = DebugGCHandle.Alloc(instance);
#else
GCHandle instanceHandle = GCHandle.Alloc(instance);
#endif
Qyoto.CPPMethod signalEntry = Qyoto.GetSignalSignature(signalsInterface, (MethodInfo)callMessage.MethodBase);
Type returnType = ((MethodInfo)returnMessage.MethodBase).ReturnType;
SignalEmit(signalEntry.signature, signalEntry.type, (IntPtr)instanceHandle, (IntPtr)stackPtr, callMessage.ArgCount);
if (returnType != typeof(void))
{
returnValue.ReturnValue = SmokeMarshallers.BoxFromStackItem(returnType, 0, stackPtr);
}
returnMessage = returnValue;
return(returnMessage);
}
}
}
public static void InitRuntime()
{
if (runtimeInitialized)
{
return;
}
Qyoto.Init_qyoto();
SmokeMarshallers.SetUp();
// not set when mono is embedded
if (AppDomain.CurrentDomain.SetupInformation.ConfigurationFile == null)
{
PropertyInfo pi = typeof(AppDomain).GetProperty("SetupInformationNoCopy", BindingFlags.NonPublic | BindingFlags.Instance);
AppDomainSetup setup = (AppDomainSetup)pi.GetValue(AppDomain.CurrentDomain, null);
setup.ConfigurationFile = Assembly.GetExecutingAssembly().Location + ".config";
}
runtimeInitialized = true;
}
public SmokeInvocation(Type klass, Object obj)
{
classToProxy = klass;
instance = obj;
className = SmokeMarshallers.SmokeClassName(klass);
TryInitialize(klass.Assembly);
if (!globalMethodIdCache.TryGetValue(classToProxy, out methodIdCache))
{
methodIdCache = new Dictionary <string, ModuleIndex>();
globalMethodIdCache[classToProxy] = methodIdCache;
}
if (instance != null)
{
AddOverridenMethods(instance.GetType());
}
}
public static MethodInfo GetSlotMethodInfo(Type klass, string slotname)
{
Dictionary <string, CPPMethod> slotTable;
CPPMethod result;
do
{
slotTable = GetSlotSignatures(klass);
if (slotTable.TryGetValue(slotname, out result))
{
return(result.mi);
}
klass = klass.BaseType;
} while (!SmokeMarshallers.IsSmokeClass(klass));
return(null);
}
public List <T> FindChildren <T>(QRegExp regExp)
{
List <T> list = new List <T>();
AddToListFn addFn = delegate(IntPtr obj) {
T o = (T)((System.Runtime.InteropServices.GCHandle)obj).Target;
list.Add(o);
};
string childClassName = null;
IntPtr metaObject = IntPtr.Zero;
if (SmokeMarshallers.IsSmokeClass(typeof(T)))
{
childClassName = SmokeMarshallers.SmokeClassName(typeof(T));
}
else
{
metaObject = (IntPtr)GCHandle.Alloc(Qyoto.GetMetaObject(typeof(T)));
}
FindQObjectChildren((IntPtr)GCHandle.Alloc(this), childClassName, metaObject, (IntPtr)GCHandle.Alloc(regExp), string.Empty, addFn);
return(list);
}
public T Create <T>(QWidget parentWidget, QObject parent, string keyword, List <QVariant> args) where T : class
{
Type type = typeof(T);
if (!SmokeMarshallers.IsSmokeClass(type))
{
throw new Exception("The generic type must be included in the bindings");
}
QObject o = Create(SmokeMarshallers.SmokeClassName(type), parentWidget, parent, args, keyword);
if (o == null)
{
return(null);
}
T t = qobject_cast <T>(o);
if (t == null)
{
o.Dispose();
}
return(t);
}
public static void InvokeMethod(IntPtr instanceHandle, IntPtr methodHandle, IntPtr stack, IntPtr typeIDs)
{
object instance = ((GCHandle)instanceHandle).Target;
MethodInfo method = (MethodInfo)((GCHandle)methodHandle).Target;
#if DEBUG
if ((QDebug.DebugChannel() & QtDebugChannel.QTDB_TRANSPARENT_PROXY) != 0 &&
(QDebug.DebugChannel() & QtDebugChannel.QTDB_VIRTUAL) != 0)
{
Console.WriteLine("ENTER InvokeMethod() {0}.{1}",
instance,
method.Name);
}
#endif
unsafe {
StackItem * stackPtr = (StackItem *)stack;
ParameterInfo[] parameters = method.GetParameters();
object[] args = new object[parameters.Length];
TypeId * typeIDsPtr = (TypeId *)typeIDs;
for (int i = 0; i < args.Length; i++)
{
args[i] = SmokeMarshallers.BoxFromStackItem(parameters[i].ParameterType, (int)typeIDsPtr[i + 1], stackPtr + i + 1);
}
object returnValue = method.Invoke(instance, args);
* typeIDsPtr = SmokeMarshallers.GetTypeId(returnValue == null ? typeof(object) : returnValue.GetType());
//TODO: should this always be unboxing something?
if (method.ReturnType != typeof(void))
{
SmokeMarshallers.UnboxToStackItem(returnValue, stackPtr);
}
}
return;
}
public static Dictionary <PropertyInfo, CPPProperty> GetProperties(Type t)
{
Dictionary <PropertyInfo, CPPProperty> props = new Dictionary <PropertyInfo, CPPProperty>();
foreach (PropertyInfo pi in t.GetProperties())
{
if (SmokeMarshallers.IsSmokeClass(pi.DeclaringType))
{
continue;
}
object[] attrs = pi.GetCustomAttributes(typeof(Q_PROPERTY), false);
if (attrs.Length != 0)
{
Q_PROPERTY attr = (Q_PROPERTY)attrs[0];
CPPProperty prop = new CPPProperty();
if (attr.Type == "" || attr.Name == "")
{
prop.type = GetPrimitiveString(pi.PropertyType);
prop.name = pi.Name;
}
else
{
prop.type = attr.Type;
prop.name = attr.Name;
}
prop.pi = pi;
if (pi.GetCustomAttributes(typeof(Q_SCRIPTABLE), false).Length != 0)
{
prop.scriptable = true;
}
props.Add(pi, prop);
}
}
return(props);
}
public static string GetPrimitiveString(Type type)
{
string typeString = type.ToString();
switch (typeString)
{
case "System.Void":
return("");
case "System.Boolean":
return("bool");
case "System.Int32":
return("int");
case "System.Int64":
return("long");
case "System.UInt32":
return("uint");
case "System.UInt64":
return("ulong");
case "System.Int16":
return("short");
case "System.UInt16":
return("ushort");
case "System.Byte":
return("uchar");
case "System.SByte":
return("sbyte");
case "System.String":
return("QString");
case "System.Double":
return("double");
case "System.Single":
return("float");
case "System.Char":
return("char");
}
if (type.IsGenericType)
{
Type[] args = type.GetGenericArguments();
if (type.FullName.StartsWith("System.Collections.Generic.List`1"))
{
return("QList<" + GetPrimitiveString(args[0]) + ">");
}
else if (type.FullName.StartsWith("System.Collections.Generic.Dictionary`2"))
{
return("QMap<" + GetPrimitiveString(args[0]) + ", " + GetPrimitiveString(args[1]) + ">");
}
}
if (SmokeMarshallers.IsSmokeClass(type))
{
typeString = SmokeMarshallers.SmokeClassName(type);
}
List <string> nonQObjectClasses = new List <string>
{
// paint devices
"QCustomRasterPaintDevice", "QGLFramebufferObject", "QGLPixelBuffer", "QImage", "QPicture", "QPixmap", "QPrinter", "QSvgGenerator",
// painters
"QStylePainter", "Q3Painter", "QPainter",
// model items
"QListWidgetItem", "QTreeWidgetItem", "QTableWidgetItem", "QStandardItem"
};
// pointer types
if (type.IsSubclassOf(typeof(QObject)) || nonQObjectClasses.Contains(typeString))
{
typeString += "*";
}
return(typeString);
}
static public QVariant FromValue(object value, System.Type valueType)
{
if (valueType == typeof(bool))
{
return(new QVariant((bool)value));
}
else if (valueType == typeof(double))
{
return(new QVariant((double)value));
}
else if (valueType == typeof(QBitArray))
{
return(new QVariant((QBitArray)value));
}
else if (valueType == typeof(QByteArray))
{
return(new QVariant((QByteArray)value));
}
else if (valueType == typeof(char))
{
return(new QVariant(new QChar((char)value)));
}
else if (valueType == typeof(QDate))
{
return(new QVariant((QDate)value));
}
else if (valueType == typeof(QDateTime))
{
return(new QVariant((QDateTime)value));
}
else if (valueType == typeof(int))
{
return(new QVariant((int)value));
}
else if (valueType == typeof(QLine))
{
return(new QVariant((QLine)value));
}
else if (valueType == typeof(QLineF))
{
return(new QVariant((QLineF)value));
}
else if (valueType == typeof(QLocale))
{
return(new QVariant((QLocale)value));
}
else if (valueType == typeof(QPoint))
{
return(new QVariant((QPoint)value));
}
else if (valueType == typeof(QPointF))
{
return(new QVariant((QPointF)value));
}
else if (valueType == typeof(QRect))
{
return(new QVariant((QRect)value));
}
else if (valueType == typeof(QRectF))
{
return(new QVariant((QRectF)value));
}
else if (valueType == typeof(QRegExp))
{
return(new QVariant((QRegExp)value));
}
else if (valueType == typeof(QSize))
{
return(new QVariant((QSize)value));
}
else if (valueType == typeof(QSizeF))
{
return(new QVariant((QSizeF)value));
}
else if (valueType == typeof(string))
{
return(new QVariant((string)value));
}
else if (valueType == typeof(List <string>))
{
return(new QVariant((List <string>)value));
}
else if (valueType == typeof(List <QVariant>))
{
return(new QVariant((List <QVariant>)value));
}
else if (valueType == typeof(Dictionary <string, QVariant>))
{
return(new QVariant((Dictionary <string, QVariant>)value));
}
else if (valueType == typeof(QTime))
{
return(new QVariant((QTime)value));
}
else if (valueType == typeof(uint))
{
return(new QVariant((uint)value));
}
else if (valueType == typeof(QUrl))
{
return(new QVariant((QUrl)value));
}
else if (valueType == typeof(QVariant))
{
return(new QVariant((QVariant)value));
}
else if (valueType.IsEnum)
{
return(new QVariant((int)value));
}
else
{
string typeName;
if (SmokeMarshallers.IsSmokeClass(valueType))
{
typeName = SmokeMarshallers.SmokeClassName(valueType);
}
else
{
typeName = valueType.ToString();
}
Type type = NameToType(typeName);
if (type == Type.Invalid)
{
return(FromValue <object>(value));
}
else if (type > Type.LastCoreType)
{
IntPtr valueHandle = IntPtr.Zero;
if (value != null)
{
valueHandle = (IntPtr)GCHandle.Alloc(value);
}
GCHandle handle = (GCHandle)QVariantFromValue(QMetaType.type(typeName), valueHandle);
QVariant v = (QVariant)handle.Target;
handle.Free();
return(v);
}
return(new QVariant());
}
}
public object Value(System.Type valueType)
{
if (valueType == typeof(bool))
{
return(ToBool());
}
else if (valueType == typeof(double))
{
return(ToDouble());
}
else if (valueType == typeof(QBitArray))
{
return(ToBitArray());
}
else if (valueType == typeof(QByteArray))
{
return(ToByteArray());
}
else if (valueType == typeof(char))
{
return(ToChar());
}
else if (valueType == typeof(QDate))
{
return(ToDate());
}
else if (valueType == typeof(QDateTime))
{
return(ToDateTime());
}
else if (valueType == typeof(int))
{
return(ToInt());
}
else if (valueType == typeof(QLine))
{
return(ToLine());
}
else if (valueType == typeof(QLineF))
{
return(ToLineF());
}
else if (valueType == typeof(QLocale))
{
return(ToLocale());
}
else if (valueType == typeof(QPoint))
{
return(ToPoint());
}
else if (valueType == typeof(QPointF))
{
return(ToPointF());
}
else if (valueType == typeof(QRect))
{
return(ToRect());
}
else if (valueType == typeof(QRectF))
{
return(ToRectF());
}
else if (valueType == typeof(QRegExp))
{
return(ToRegExp());
}
else if (valueType == typeof(QSize))
{
return(ToSize());
}
else if (valueType == typeof(QSizeF))
{
return(ToSizeF());
}
else if (valueType == typeof(string))
{
return(ToString());
}
else if (valueType == typeof(List <string>))
{
return(ToStringList());
}
else if (valueType == typeof(List <QVariant>))
{
return(ToList());
}
else if (valueType == typeof(Dictionary <string, QVariant>))
{
object o = ToMap();
if (o == null)
{
o = ToHash();
}
return(o);
}
else if (valueType == typeof(QTime))
{
return(ToTime());
}
else if (valueType == typeof(uint))
{
return(ToUInt());
}
else if (valueType == typeof(QUrl))
{
return(ToUrl());
}
else if (valueType == typeof(QVariant))
{
return(this);
}
else if (valueType.IsEnum)
{
return(Enum.ToObject(valueType, ToLongLong()));
}
else
{
string typeName;
if (SmokeMarshallers.IsSmokeClass(valueType))
{
typeName = SmokeMarshallers.SmokeClassName(valueType);
}
else
{
typeName = valueType.ToString();
}
Type type = NameToType(typeName);
if (type > Type.LastCoreType)
{
IntPtr instancePtr = QVariantValue(typeName, (IntPtr)GCHandle.Alloc(this));
return(((GCHandle)instancePtr).Target);
}
else if (type == Type.Invalid)
{
Console.WriteLine("QVariant.Value(): invalid type: {0}", valueType);
}
return(null);
}
}
public object Invoke(string mungedName, string signature, Type returnType, bool refArgs, params object[] args)
{
#if DEBUG
if ((QDebug.DebugChannel() & QtDebugChannel.QTDB_TRANSPARENT_PROXY) != 0)
{
Console.WriteLine("ENTER SmokeInvocation.Invoke() MethodName: {0}.{1} Type: {2} ArgCount: {3}",
className,
signature,
returnType,
args.Length / 2);
}
#endif
if (signature.StartsWith("operator=="))
{
if (args[1] == null && args[3] == null)
{
return(true);
}
else if (args[1] == null || args[3] == null)
{
return(false);
}
}
ModuleIndex methodId;
methodId.smoke = IntPtr.Zero;
methodId.index = -1;
if (!methodIdCache.TryGetValue(signature, out methodId))
{
methodId = FindMethodId(className, mungedName, signature);
if (methodId.index == -1)
{
Console.Error.WriteLine("LEAVE Invoke() ** Missing method ** {0}.{1}",
className,
signature);
return(null);
}
methodIdCache[signature] = methodId;
}
StackItem[] stack = new StackItem[(args.Length / 2) + 1];
TypeId[] typeIDs = new TypeId[(args.Length / 2) + 1];
unsafe
{
fixed(StackItem *stackPtr = stack)
{
fixed(TypeId *typeIDsPtr = typeIDs)
{
typeIDs[0] = 0;
for (int i = 1, k = 1; i < args.Length; i += 2, k++)
{
typeIDs[k] = SmokeMarshallers.UnboxToStackItem(args[i], stackPtr + k);
}
object returnValue = null;
if (instance == null)
{
CallSmokeMethod(methodId.smoke, (int)methodId.index, (IntPtr)0, (IntPtr)stackPtr, args.Length / 2, (IntPtr)typeIDsPtr);
}
else
{
#if DEBUG
GCHandle instanceHandle = DebugGCHandle.Alloc(instance);
#else
GCHandle instanceHandle = GCHandle.Alloc(instance);
#endif
CallSmokeMethod(methodId.smoke, methodId.index, (IntPtr)instanceHandle, (IntPtr)stackPtr, args.Length / 2, (IntPtr)typeIDsPtr);
#if DEBUG
DebugGCHandle.Free(instanceHandle);
#else
instanceHandle.Free();
#endif
}
if (returnType != typeof(void))
{
returnValue = SmokeMarshallers.BoxFromStackItem(returnType, (int)typeIDs[0], stackPtr);
}
if (refArgs)
{
for (int i = 1, k = 1; i < args.Length; i += 2, k++)
{
Type t = args[i].GetType();
if (t.IsPrimitive || t == typeof(NativeLong) || t == typeof(NativeULong))
{
args[i] = SmokeMarshallers.BoxFromStackItem(args[i].GetType(), (int)typeIDs[k], stackPtr + k);
}
}
}
return(returnValue);
}
}
}
}
public static void Cleanup()
{
SmokeMarshallers.ConvertRefs();
SetApplicationTerminated();
}
public static QMetaObject MakeMetaObject(Type t)
{
if (t == null)
{
return(null);
}
QMetaObject parentMeta = null;
string parentClassName = null;
if (!SmokeMarshallers.IsSmokeClass(t.BaseType) &&
!metaObjects.TryGetValue(t.BaseType, out parentMeta))
{
// create QMetaObject
parentMeta = MakeMetaObject(t.BaseType);
}
else
{
parentClassName = SmokeMarshallers.SmokeClassName(t.BaseType);
}
ICollection <CPPMethod> slots;
// build slot table
slots = GetSlotSignatures(t).Values;
PropertyInfo pi = t.GetProperty("Emit", BindingFlags.Instance
| BindingFlags.NonPublic
| BindingFlags.DeclaredOnly);
ICollection <CPPMethod> signals = null;
if (pi == null)
{
signals = new List <CPPMethod>();
}
else
{
emitInterfaceCache[t] = pi.PropertyType;
signals = GetSignalSignatures(pi.PropertyType).Values;
}
ICollection <CPPProperty> properties = GetProperties(t).Values;
QyotoMetaData metaData = new QyotoMetaData(t.Name, signals, slots, GetClassInfos(t), properties);
IntPtr metaObject;
IntPtr parentMetaPtr = (IntPtr)0;
unsafe
{
fixed(byte *stringdata = metaData.StringData)
fixed(uint *data = metaData.Data)
{
if (parentMeta != null)
{
#if DEBUG
parentMetaPtr = (IntPtr)DebugGCHandle.Alloc(parentMeta);
#else
parentMetaPtr = (IntPtr)GCHandle.Alloc(parentMeta);
#endif
}
metaObject = qyoto_make_metaObject(parentClassName,
parentMetaPtr,
(IntPtr)stringdata, metaData.StringData.Length,
(IntPtr)data, metaData.Data.Length);
}
}
QMetaObject res = (QMetaObject)((GCHandle)metaObject).Target;
#if DEBUG
DebugGCHandle.Free((GCHandle)metaObject);
#else
((GCHandle)metaObject).Free();
#endif
metaObjects.Add(t, res);
return(res);
}
static void AddOverridenMethods(Type klass)
{
if (SmokeMarshallers.IsSmokeClass(klass))
{
return;
}
if (overridenMethods.ContainsKey(klass))
{
return;
}
Dictionary <string, MemberInfo> methodsHash = new Dictionary <string, MemberInfo>();
overridenMethods.Add(klass, methodsHash);
do
{
MemberInfo[] methods = klass.FindMembers(MemberTypes.Method,
BindingFlags.Public
| BindingFlags.NonPublic
| BindingFlags.Instance
| BindingFlags.DeclaredOnly,
Type.FilterName,
"*");
foreach (MemberInfo method in methods)
{
Type parent = klass.BaseType;
string signature = null;
while (signature == null && parent != null && parent != typeof(Qt))
{
MemberInfo[] parentMethods = parent.FindMembers(MemberTypes.Method,
BindingFlags.Public
| BindingFlags.NonPublic
| BindingFlags.Instance
| BindingFlags.DeclaredOnly,
Type.FilterName,
method.Name);
foreach (MemberInfo parentMethod in parentMethods)
{
if (method.ToString() == parentMethod.ToString())
{
object[] smokeMethod = parentMethod.GetCustomAttributes(typeof(SmokeMethod), false);
if (smokeMethod.Length > 0)
{
signature = ((SmokeMethod)smokeMethod[0]).Signature;
}
}
}
parent = parent.BaseType;
}
if (signature != null && !methodsHash.ContainsKey(signature))
{
methodsHash.Add(signature, method);
}
}
klass = klass.BaseType;
} while (!SmokeMarshallers.IsSmokeClass(klass));
}
public static string GetPrimitiveString(Type type)
{
string typeString = type.ToString();
switch (typeString)
{
case "System.Void":
return("");
case "System.Boolean":
return("bool");
case "System.Int32":
return("int");
case "System.Int64":
return("long");
case "System.UInt32":
return("uint");
case "System.UInt64":
return("ulong");
case "System.Int16":
return("short");
case "System.UInt16":
return("ushort");
case "System.Byte":
return("uchar");
case "System.SByte":
return("sbyte");
case "System.String":
return("QString");
case "System.Double":
return("double");
case "System.Single":
return("float");
case "System.Char":
return("char");
}
if (type.IsGenericType)
{
Type[] args = type.GetGenericArguments();
if (type.FullName.StartsWith("System.Collections.Generic.List`1"))
{
return("QList<" + GetPrimitiveString(args[0]) + ">");
}
else if (type.FullName.StartsWith("System.Collections.Generic.Dictionary`2"))
{
return("QMap<" + GetPrimitiveString(args[0]) + ", " + GetPrimitiveString(args[1]) + ">");
}
}
if (SmokeMarshallers.IsSmokeClass(type))
{
typeString = SmokeMarshallers.SmokeClassName(type);
}
// pointer types
if (type.IsSubclassOf(typeof(QObject)) ||
typeString == "QListWidgetItem" ||
typeString == "QTreeWidgetItem" ||
typeString == "QTableWidgetItem" ||
typeString == "QStandardItem")
{
typeString += "*";
}
return(typeString);
}
