Classes
struct	Method

struct	Property

Public Functions
void	addClassInfo (const char key, const char value)

QMetaObject *	metaObject (const QMetaObject *parentObject, const QByteArray &className=QByteArray())

	MetaObjectGenerator (QAxBase ax, QAxBasePrivate dptr)

	MetaObjectGenerator (ITypeLib typelib, ITypeInfo typeinfo)

void	readClassInfo ()

void	readEnumInfo ()

void	readEventInfo ()

void	readEventInterface (ITypeInfo eventinfo, IConnectionPoint cpoint)

void	readFuncsInfo (ITypeInfo *typeinfo, ushort nFuncs)

void	readInterfaceInfo ()

void	readVarsInfo (ITypeInfo *typeinfo, ushort nVars)

	~MetaObjectGenerator ()

Private Types
enum	MemberFlags { AccessPrivate = 0x00, AccessProtected = 0x01, AccessPublic = 0x02, MemberMethod = 0x00, MemberSignal = 0x04, MemberSlot = 0x08, MemberCompatibility = 0x10, MemberCloned = 0x20, MemberScriptable = 0x40 }

enum	ProperyFlags { Invalid = 0x00000000, Readable = 0x00000001, Writable = 0x00000002, Resettable = 0x00000004, EnumOrFlag = 0x00000008, StdCppSet = 0x00000100, Designable = 0x00001000, ResolveDesignable = 0x00002000, Scriptable = 0x00004000, ResolveScriptable = 0x00008000, Stored = 0x00010000, ResolveStored = 0x00020000, Editable = 0x00040000, ResolveEditable = 0x00080000, User = 0x00100000, ResolveUser = 0x00200000, RequestingEdit = 0x00400000, Bindable = 0x00800000 }

Private Functions
void	addChangedSignal (const QByteArray &function, const QByteArray &type, int memid)

void	addEnumValue (const QByteArray &enumname, const QByteArray &key, int value)

void	addProperty (const QByteArray &type, const QByteArray &name, uint flags)

void	addSetterSlot (const QByteArray &property)

void	addSignal (const QByteArray &prototype, const QByteArray &parameters)

void	addSlot (const QByteArray &type, const QByteArray &prototype, const QByteArray &parameters, int flags=QMetaMethod::Public)

QByteArray	createPrototype (FUNCDESC funcdesc, ITypeInfo typeinfo, const QList< QByteArray > &names, QByteArray &type, QList< QByteArray > &parameters)

QByteArray	guessTypes (const TYPEDESC &tdesc, ITypeInfo *info, const QByteArray &function)

bool	hasClassInfo (const char *key)

bool	hasEnum (const QByteArray &enumname)

bool	hasProperty (const QByteArray &name)

bool	hasSignal (const QByteArray &prototype)

bool	hasSlot (const QByteArray &prototype)

void	init ()

QList< QByteArray >	paramList (const QByteArray &proto)

QByteArray	propertyType (const QByteArray &name)

QByteArray	replacePrototype (const QByteArray &prototype)

QByteArray	replaceType (const QByteArray &type)

QMetaObject *	tryCache ()

QByteArray	usertypeToString (const TYPEDESC &tdesc, ITypeInfo *info, const QByteArray &function)

Properties
QString	cacheKey

ITypeInfo *	classInfo

QMap< QByteArray, QByteArray >	classinfo_list

QByteArray	current_typelib

QAxBasePrivate *	d

QByteArray	debugInfo

IDispatch *	disp

ITypeInfo *	dispInfo

QMap< QByteArray, QList< QPair< QByteArray, int > > >	enum_list

QUuid	iid_propNotifySink

QSettings	iidnames

QMap< QByteArray, Property >	property_list

QMap< QByteArray, Method >	signal_list

QMap< QByteArray, Method >	slot_list

QAxBase *	that

ITypeLib *	typelib

Friends
QMetaObject *	qax_readClassInfo (ITypeLib typeLib, ITypeInfo classInfo, const QMetaObject *parentObject)

Detailed Description

Definition at line 1493 of file qaxbase.cpp.

Enumerations

◆ MemberFlags

enum MetaObjectGenerator::MemberFlags

private

Enumerator
AccessPrivate
AccessProtected
AccessPublic
MemberMethod
MemberSignal
MemberSlot
MemberCompatibility
MemberCloned
MemberScriptable

Definition at line 1550 of file qaxbase.cpp.

                      {
         AccessPrivate = 0x00,
         AccessProtected = 0x01,
         AccessPublic = 0x02,
         MemberMethod = 0x00,
         MemberSignal = 0x04,
         MemberSlot = 0x08,
         MemberCompatibility = 0x10,
         MemberCloned = 0x20,
         MemberScriptable = 0x40,
     };

◆ ProperyFlags

enum MetaObjectGenerator::ProperyFlags

private

Enumerator
Invalid
Readable
Writable
Resettable
EnumOrFlag
StdCppSet
Designable
ResolveDesignable
Scriptable
ResolveScriptable
Stored
ResolveStored
Editable
ResolveEditable
User
ResolveUser
RequestingEdit
Bindable

Definition at line 1528 of file qaxbase.cpp.

                        {
         Invalid         = 0x00000000,
         Readable        = 0x00000001,
         Writable        = 0x00000002,
         Resettable      = 0x00000004,
         EnumOrFlag      = 0x00000008,
         StdCppSet       = 0x00000100,
 //        Override      = 0x00000200,
         Designable      = 0x00001000,
         ResolveDesignable   = 0x00002000,
         Scriptable      = 0x00004000,
         ResolveScriptable   = 0x00008000,
         Stored                  = 0x00010000,
         ResolveStored           = 0x00020000,
         Editable        = 0x00040000,
         ResolveEditable         = 0x00080000,
         User                    = 0x00100000,
         ResolveUser             = 0x00200000,
         // And our own - don't use the upper byte, as it's used for the property type
         RequestingEdit          = 0x00400000,
         Bindable                = 0x00800000
     };

Constructors and Destructors

◆ MetaObjectGenerator() [1/2]

MetaObjectGenerator::MetaObjectGenerator	(	QAxBase *	ax,
		QAxBasePrivate *	dptr
	)

Definition at line 1839 of file qaxbase.cpp.

 : that(ax), d(dptr), disp(0), dispInfo(0), classInfo(0), typelib(0),
   iidnames(QLatin1String("HKEY_LOCAL_MACHINE\\Software\\Classes"), QSettings::NativeFormat)
 {
     init();
 }

◆ MetaObjectGenerator() [2/2]

MetaObjectGenerator::MetaObjectGenerator	(	ITypeLib *	typelib,
		ITypeInfo *	typeinfo
	)

Definition at line 1846 of file qaxbase.cpp.

 : that(0), d(0), disp(0), dispInfo(tinfo), classInfo(0), typelib(tlib),
   iidnames(QLatin1String("HKEY_LOCAL_MACHINE\\Software\\Classes"), QSettings::NativeFormat)
 {
     init();
 
     if (dispInfo)
         dispInfo->AddRef();
     if (typelib) {
         typelib->AddRef();
         BSTR bstr;
         typelib->GetDocumentation(-1, &bstr, 0, 0, 0);
         current_typelib = QString::fromWCharArray(bstr).toLatin1();
         SysFreeString(bstr);
     }
     readClassInfo();
 }

◆ ~MetaObjectGenerator()

MetaObjectGenerator::~MetaObjectGenerator ( )

Definition at line 1879 of file qaxbase.cpp.

 {
     if (dispInfo) dispInfo->Release();
     if (classInfo) classInfo->Release();
     if (typelib) typelib->Release();
 }

Functions

◆ addChangedSignal()

void MetaObjectGenerator::addChangedSignal	(	const QByteArray &	function,
		const QByteArray &	type,
		int	memid
	)

private

Definition at line 2349 of file qaxbase.cpp.

Referenced by readFuncsInfo(), and readVarsInfo().

 {
     QAxEventSink *eventSink = 0;
     if (d) {
         eventSink = d->eventSink.value(iid_propNotifySink);
         if (!eventSink && d->useEventSink) {
             eventSink = new QAxEventSink(that);
             d->eventSink.insert(iid_propNotifySink, eventSink);
         }
     }
     // generate changed signal
     QByteArray signalName(function);
     signalName += "Changed";
     QByteArray signalProto = signalName + '(' + replaceType(type) + ')';
     if (!hasSignal(signalProto))
         addSignal(signalProto, function);
     if (eventSink)
         eventSink->addProperty(memid, function, signalProto);
 }

◆ addClassInfo()

void MetaObjectGenerator::addClassInfo	(	const char *	key,
		const char *	value
	)

inline

Definition at line 1510 of file qaxbase.cpp.

Referenced by metaObject(), qax_readClassInfo(), readClassInfo(), readEventInfo(), and readInterfaceInfo().

     {
         classinfo_list.insert(key, value);
     }

◆ addEnumValue()

void MetaObjectGenerator::addEnumValue	(	const QByteArray &	enumname,
		const QByteArray &	key,
		int	value
	)

inlineprivate

Definition at line 1717 of file qaxbase.cpp.

Referenced by readEnumInfo().

     {
         enum_list[enumname].append(QPair<QByteArray, int>(key, value));
     }

◆ addProperty()

void MetaObjectGenerator::addProperty	(	const QByteArray &	type,
		const QByteArray &	name,
		uint	flags
	)

inlineprivate

Definition at line 1674 of file qaxbase.cpp.

Referenced by init(), readFuncsInfo(), and readVarsInfo().

     {
         QByteArray propertyType(type);
         if (propertyType.endsWith('&'))
             propertyType.chop(1);
 
         Property &prop = property_list[name];
         if (!propertyType.isEmpty() && propertyType != "HRESULT") {
             prop.type = replaceType(propertyType);
             if (prop.type != propertyType)
                 prop.realType = propertyType;
         }
         if (flags & Writable)
             flags |= Stored;
         prop.typeId |= flags;
         QVariant::Type vartype = QVariant::nameToType(prop.type);
         switch(vartype) {
         case QVariant::Invalid:
         case QVariant::UserType:
             if (prop.type == "QVariant") {
                 prop.typeId |= 0xff << 24;
                 break;
             }
             if (QMetaType::type(prop.type) == -1)
                 qWarning("QAxBase: Unsupported property type: %s", prop.type.data());
             break;
         default:
             prop.typeId |= vartype << 24;
             break;
         }
     }

◆ addSetterSlot()

void MetaObjectGenerator::addSetterSlot ( const QByteArray & property )

private

Definition at line 2369 of file qaxbase.cpp.

Referenced by readFuncsInfo(), and readVarsInfo().

 {
     QByteArray set;
     QByteArray prototype(property);
     if (isupper(prototype.at(0))) {
         set = "Set";
     } else {
         set = "set";
         prototype[0] = toupper(prototype[0]);
     }
     prototype = set + prototype + '(' + propertyType(property) + ')';
     if (!hasSlot(prototype))
         addSlot(0, prototype, property);
 }

◆ addSignal()

void MetaObjectGenerator::addSignal	(	const QByteArray &	prototype,
		const QByteArray &	parameters
	)

inlineprivate

Definition at line 1627 of file qaxbase.cpp.

Referenced by addChangedSignal(), init(), qax_readClassInfo(), and readEventInterface().

     {
         QByteArray proto(replacePrototype(prototype));
 
         Method &signal = signal_list[proto];
         signal.type = 0;
         signal.parameters = parameters;
         signal.flags = QMetaMethod::Public | MemberSignal;
         if (proto != prototype)
             signal.realPrototype = prototype;
     }

◆ addSlot()

void MetaObjectGenerator::addSlot	(	const QByteArray &	type,
		const QByteArray &	prototype,
		const QByteArray &	parameters,
		int	flags = `QMetaMethod::Public`
	)

inlineprivate

Definition at line 1647 of file qaxbase.cpp.

Referenced by addSetterSlot(), and readFuncsInfo().

     {
         QByteArray proto = replacePrototype(prototype);
 
         Method &slot = slot_list[proto];
         slot.type = replaceType(type);
         slot.parameters = parameters;
         slot.flags = flags | MemberSlot;
         if (proto != prototype)
             slot.realPrototype = prototype;
     }

◆ createPrototype()

QByteArray MetaObjectGenerator::createPrototype	(	FUNCDESC *	funcdesc,
		ITypeInfo *	typeinfo,
		const QList< QByteArray > &	names,
		QByteArray &	type,
		QList< QByteArray > &	parameters
	)

private

Definition at line 2384 of file qaxbase.cpp.

Referenced by readEventInterface(), and readFuncsInfo().

 {
     QByteArray prototype;
     QByteArray function(names.at(0));
     const QByteArray hresult("HRESULT");
     // get function prototype
     type = guessTypes(funcdesc->elemdescFunc.tdesc, typeinfo, function);
     if ((type.isEmpty() || type == hresult) && funcdesc->invkind == INVOKE_PROPERTYPUT && funcdesc->lprgelemdescParam) {
         type = guessTypes(funcdesc->lprgelemdescParam->tdesc, typeinfo, function);
     }
 
     prototype = function + '(';
     if (funcdesc->invkind == INVOKE_FUNC && type == hresult)
         type = 0;
 
     int p;
     for (p = 1; p < names.count(); ++p) {
         // parameter
         QByteArray paramName = names.at(p);
         bool optional = p > (funcdesc->cParams - funcdesc->cParamsOpt);
         TYPEDESC tdesc = funcdesc->lprgelemdescParam[p-1].tdesc;
         PARAMDESC pdesc = funcdesc->lprgelemdescParam[p-1].paramdesc;
 
         QByteArray ptype = guessTypes(tdesc, typeinfo, function);
         if (pdesc.wParamFlags & PARAMFLAG_FRETVAL) {
             if (ptype.endsWith('&')) {
                 ptype.truncate(ptype.length() - 1);
             } else if (ptype.endsWith("**")) {
                 ptype.truncate(ptype.length() - 1);
             }
             type = ptype;
         } else {
             prototype += ptype;
             if (pdesc.wParamFlags & PARAMFLAG_FOUT && !ptype.endsWith('&') && !ptype.endsWith("**"))
                 prototype += '&';
             if (optional || pdesc.wParamFlags & PARAMFLAG_FOPT)
                 paramName += "=0";
             else if (pdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) {
                 // ### get the value from pdesc.pparamdescex
                 paramName += "=0";
             }
             parameters << paramName;
         }
         if (p < funcdesc->cParams && !(pdesc.wParamFlags & PARAMFLAG_FRETVAL))
             prototype += ',';
     }
 
     if (!prototype.isEmpty()) {
         if (prototype.endsWith(',')) {
             if (funcdesc->invkind == INVOKE_PROPERTYPUT && p == funcdesc->cParams) {
                 TYPEDESC tdesc = funcdesc->lprgelemdescParam[p-1].tdesc;
                 QByteArray ptype = guessTypes(tdesc, typeinfo, function);
                 prototype += ptype;
                 prototype += ')';
                 parameters << "rhs";
             } else {
                 prototype[prototype.length()-1] = ')';
             }
         } else {
             prototype += ')';
         }
     }
 
     return prototype;
 }

◆ guessTypes()

QByteArray MetaObjectGenerator::guessTypes	(	const TYPEDESC &	tdesc,
		ITypeInfo *	info,
		const QByteArray &	function
	)

private

Definition at line 1977 of file qaxbase.cpp.

Referenced by createPrototype(), readVarsInfo(), and usertypeToString().

 {
     QByteArray str;
     switch (tdesc.vt) {
     case VT_EMPTY:
     case VT_VOID:
         break;
     case VT_LPWSTR:
         str = "wchar_t *";
         break;
     case VT_BSTR:
         str = "QString";
         break;
     case VT_BOOL:
         str = "bool";
         break;
     case VT_I1:
         str = "char";
         break;
     case VT_I2:
         str = "short";
         break;
     case VT_I4:
     case VT_INT:
         str = "int";
         break;
     case VT_I8:
         str = "qlonglong";
         break;
     case VT_UI1:
     case VT_UI2:
     case VT_UI4:
     case VT_UINT:
         str = "uint";
         break;
     case VT_UI8:
         str = "qulonglong";
         break;
     case VT_CY:
         str = "qlonglong";
         break;
     case VT_R4:
         str = "float";
         break;
     case VT_R8:
         str = "double";
         break;
     case VT_DATE:
         str = "QDateTime";
         break;
     case VT_DISPATCH:
         str = "IDispatch*";
         break;
     case VT_VARIANT:
         str = "QVariant";
         break;
     case VT_UNKNOWN:
         str = "IUnknown*";
         break;
     case VT_HRESULT:
         str = "HRESULT";
         break;
     case VT_PTR:
         str = guessTypes(*tdesc.lptdesc, info, function);
         switch(tdesc.lptdesc->vt) {
         case VT_VOID:
             str = "void*";
             break;
         case VT_VARIANT:
         case VT_BSTR:
         case VT_I1:
         case VT_I2:
         case VT_I4:
         case VT_I8:
         case VT_UI1:
         case VT_UI2:
         case VT_UI4:
         case VT_UI8:
         case VT_BOOL:
         case VT_R4:
         case VT_R8:
         case VT_INT:
         case VT_UINT:
         case VT_CY:
             str += '&';
             break;
         case VT_PTR:
             if (str == "QFont" || str == "QPixmap") {
                 str += '&';
                 break;
             } else if (str == "void*") {
                 str = "void **";
                 break;
             }
             // FALLTHROUGH
         default:
             if (str == "QColor")
                 str += '&';
             else if (str == "QDateTime")
                 str += '&';
             else if (str == "QVariantList")
                 str += '&';
             else if (str == "QByteArray")
                 str += '&';
             else if (str == "QStringList")
                 str += '&';
             else if (!str.isEmpty() && hasEnum(str))
                 str += '&';
             else if (!str.isEmpty() && str != "QFont" && str != "QPixmap" && str != "QVariant")
                 str += '*';
         }
         break;
     case VT_SAFEARRAY:
         switch(tdesc.lpadesc->tdescElem.vt) {
         // some shortcuts, and generic support for lists of QVariant-supported types
         case VT_UI1:
             str = "QByteArray";
             break;
         case VT_BSTR:
             str = "QStringList";
             break;
         case VT_VARIANT:
             str = "QVariantList";
             break;
         default:
             str = guessTypes(tdesc.lpadesc->tdescElem, info, function);
             if (!str.isEmpty())
                 str = "QList<" + str + '>';
             break;
         }
         break;
     case VT_CARRAY:
         str = guessTypes(tdesc.lpadesc->tdescElem, info, function);
         if (!str.isEmpty()) {
             for (int index = 0; index < tdesc.lpadesc->cDims; ++index)
                 str += '[' + QByteArray::number((int)tdesc.lpadesc->rgbounds[index].cElements) + ']';
         }
         break;
     case VT_USERDEFINED:
         str = usertypeToString(tdesc, info, function);
         break;
 
     VT_UNHANDLED(FILETIME);
     VT_UNHANDLED(BLOB);
     VT_UNHANDLED(ERROR);
     VT_UNHANDLED(DECIMAL);
     VT_UNHANDLED(LPSTR);
     default:
         break;
     }
 
     if (tdesc.vt & VT_BYREF)
         str += '&';
 
     str.replace("&*", "**");
     return str;
 }

◆ hasClassInfo()

bool MetaObjectGenerator::hasClassInfo ( const char * key )

inlineprivate

Definition at line 1613 of file qaxbase.cpp.

Referenced by readClassInfo().

     {
         return classinfo_list.contains(key);
     }

◆ hasEnum()

bool MetaObjectGenerator::hasEnum ( const QByteArray & enumname )

inlineprivate

Definition at line 1722 of file qaxbase.cpp.

Referenced by guessTypes(), readFuncsInfo(), readVarsInfo(), and usertypeToString().

     {
         return enum_list.contains(enumname);
     }

◆ hasProperty()

bool MetaObjectGenerator::hasProperty ( const QByteArray & name )

inlineprivate

Definition at line 1706 of file qaxbase.cpp.

Referenced by readFuncsInfo(), and readVarsInfo().

     {
         return property_list.contains(name);
     }

◆ hasSignal()

bool MetaObjectGenerator::hasSignal ( const QByteArray & prototype )

inlineprivate

Definition at line 1641 of file qaxbase.cpp.

Referenced by addChangedSignal(), and readEventInterface().

     {
         return signal_list.contains(prototype);
     }

◆ hasSlot()

bool MetaObjectGenerator::hasSlot ( const QByteArray & prototype )

inlineprivate

Definition at line 1661 of file qaxbase.cpp.

Referenced by addSetterSlot().

     {
         return slot_list.contains(prototype);
     }

◆ init()

void MetaObjectGenerator::init ( )

private

Definition at line 1864 of file qaxbase.cpp.

Referenced by MetaObjectGenerator().

 {
     if (d)
         disp = d->dispatch();
 
     iid_propNotifySink = IID_IPropertyNotifySink;
 
     addSignal("signal(QString,int,void*)", "name,argc,argv");
     addSignal("exception(int,QString,QString,QString)", "code,source,disc,help");
     addSignal("propertyChanged(QString)", "name");
     if (d || dispInfo) {
         addProperty("QString", "control", Readable|Writable|Designable|Scriptable|Stored|Editable|StdCppSet);
     }
 }

◆ metaObject()

QMetaObject * MetaObjectGenerator::metaObject	(	const QMetaObject *	parentObject,
		const QByteArray &	className = `QByteArray()`
	)

Definition at line 2995 of file qaxbase.cpp.

Referenced by QAxBase::dynamicCallHelper(), QAxBase::internalInvoke(), QAxBase::internalProperty(), QAxBase::metaObject(), QAxBase::propertyBag(), qax_noSuchFunction(), qax_readClassInfo(), qax_readEnumInfo(), qax_readInterfaceInfo(), QAxBase::qt_metacall(), QAxBase::querySubObject(), and QAxBase::setPropertyBag().

 {
     if (that) {
         readClassInfo();
         if (typelib) {
             BSTR bstr;
             typelib->GetDocumentation(-1, &bstr, 0, 0, 0);
             current_typelib = QString::fromWCharArray(bstr).toLatin1();
             SysFreeString(bstr);
         }
         if (d->tryCache && tryCache())
             return d->metaobj;
         readEnumInfo();
         readInterfaceInfo();
         readEventInfo();
     }
 
     current_typelib = QByteArray();
 
 #ifndef QAX_NO_CLASSINFO
     if (!debugInfo.isEmpty() && d->useClassInfo)
         addClassInfo("debugInfo", debugInfo);
 #endif
 
     QAxMetaObject *metaobj = new QAxMetaObject;
 
     // revision + classname + table + zero terminator
     uint int_data_size = 1+1+2+2+2+2+1;
 
     int_data_size += classinfo_list.count() * 2;
     int_data_size += signal_list.count() * 5;
     int_data_size += slot_list.count() * 5;
     int_data_size += property_list.count() * 3;
     int_data_size += enum_list.count() * 4;
     for (QMap<QByteArray, QList<QPair<QByteArray, int> > >::ConstIterator it = enum_list.begin();
     it != enum_list.end(); ++it) {
         int_data_size += (*it).count() * 2;
     }
 
     uint *int_data = new uint[int_data_size];
     int_data[0] = 1; // revision number
     int_data[1] = 0; // classname index
     int_data[2] = classinfo_list.count(); // num_classinfo
     int_data[3] = 10; // idx_classinfo
     int_data[4] = signal_list.count() + slot_list.count(); // num_methods
     int_data[5] = int_data[3] + int_data[2] * 2; // idx_signals
     int_data[6] = property_list.count(); // num_properties
     int_data[7] = int_data[5] + int_data[4] * 5; // idx_properties
     int_data[8] = enum_list.count(); // num_enums
     int_data[9] = int_data[7] + int_data[6] * 3; // idx_enums
     int_data[int_data_size - 1] = 0; // eod;
 
     char null('\0');
     // data + zero-terminator
     QByteArray stringdata = that ? QByteArray(that->className()) : className;
     stringdata += null;
     stringdata.reserve(8192);
 
     uint offset = int_data[3]; //idx_classinfo
 
     // each class info in form key\0value\0
     for (QMap<QByteArray, QByteArray>::ConstIterator it = classinfo_list.begin(); it != classinfo_list.end(); ++it) {
         QByteArray key(it.key());
         QByteArray value(it.value());
         int_data[offset++] = stringdata.length();
         stringdata += key;
         stringdata += null;
         int_data[offset++] = stringdata.length();
         stringdata += value;
         stringdata += null;
     }
     Q_ASSERT(offset == int_data[5]);
 
     // each signal in form prototype\0parameters\0type\0tag\0
     for (QMap<QByteArray, Method>::ConstIterator it = signal_list.begin(); it != signal_list.end(); ++it) {
         QByteArray prototype(QMetaObject::normalizedSignature(it.key()));
         QByteArray type(it.value().type);
         QByteArray parameters(it.value().parameters);
         if (!it.value().realPrototype.isEmpty())
             metaobj->realPrototype.insert(prototype, it.value().realPrototype);
         QByteArray tag;
         int flags = it.value().flags;
 
         int_data[offset++] = stringdata.length();
         stringdata += prototype;
         stringdata += null;
         int_data[offset++] = stringdata.length();
         stringdata += parameters;
         stringdata += null;
         int_data[offset++] = stringdata.length();
         stringdata += type;
         stringdata += null;
         int_data[offset++] = stringdata.length();
         stringdata += tag;
         stringdata += null;
         int_data[offset++] = flags;
     }
 
     // each slot in form prototype\0parameters\0type\0tag\0
     for (QMap<QByteArray, Method>::ConstIterator it = slot_list.begin(); it != slot_list.end(); ++it) {
         QByteArray prototype(QMetaObject::normalizedSignature(it.key()));
         QByteArray type(it.value().type);
         QByteArray parameters(it.value().parameters);
         if (!it.value().realPrototype.isEmpty())
             metaobj->realPrototype.insert(prototype, it.value().realPrototype);
         QByteArray tag;
         int flags = it.value().flags;
 
         int_data[offset++] = stringdata.length();
         stringdata += prototype;
         stringdata += null;
         int_data[offset++] = stringdata.length();
         stringdata += parameters;
         stringdata += null;
         int_data[offset++] = stringdata.length();
         stringdata += type;
         stringdata += null;
         int_data[offset++] = stringdata.length();
         stringdata += tag;
         stringdata += null;
         int_data[offset++] = flags;
     }
     Q_ASSERT(offset == int_data[7]);
 
     // each property in form name\0type\0
     for (QMap<QByteArray, Property>::ConstIterator it = property_list.begin(); it != property_list.end(); ++it) {
         QByteArray name(it.key());
         QByteArray type(it.value().type);
         QByteArray realType(it.value().realType);
         if (!realType.isEmpty() && realType != type)
             metaobj->realPrototype.insert(name, realType);
         uint flags = it.value().typeId;
 
         int_data[offset++] = stringdata.length();
         stringdata += name;
         stringdata += null;
         int_data[offset++] = stringdata.length();
         stringdata += type;
         stringdata += null;
         int_data[offset++] = flags;
     }
     Q_ASSERT(offset == int_data[9]);
 
     int value_offset = offset + enum_list.count() * 4;
     // each enum in form name\0
     for (QMap<QByteArray, QList<QPair<QByteArray, int> > >::ConstIterator it = enum_list.begin(); it != enum_list.end(); ++it) {
         QByteArray name(it.key());
         int flags = 0x0; // 0x1 for flag?
         int count = it.value().count();
 
         int_data[offset++] = stringdata.length();
         stringdata += name;
         stringdata += null;
         int_data[offset++] = flags;
         int_data[offset++] = count;
         int_data[offset++] = value_offset;
         value_offset += count * 2;
     }
     Q_ASSERT(offset == int_data[9] + enum_list.count() * 4);
 
     // each enum value in form key\0
     for (QMap<QByteArray, QList<QPair<QByteArray, int> > >::ConstIterator it = enum_list.begin(); it != enum_list.end(); ++it) {
         for (QList<QPair<QByteArray,int> >::ConstIterator it2 = it.value().begin(); it2 != it.value().end(); ++it2) {
             QByteArray key((*it2).first);
             int value = (*it2).second;
             int_data[offset++] = stringdata.length();
             stringdata += key;
             stringdata += null;
             int_data[offset++] = value;
         }
     }
     Q_ASSERT(offset == int_data_size-1);
 
     char *string_data = new char[stringdata.length()];
     memcpy(string_data, stringdata, stringdata.length());
 
     // put the metaobject together
     metaobj->d.data = int_data;
     metaobj->d.extradata = 0;
     metaobj->d.stringdata = string_data;
     metaobj->d.superdata = parentObject;
 
     if (d)
         d->metaobj = metaobj;
 
     if (!cacheKey.isEmpty()) {
         mo_cache.insert(cacheKey, d->metaobj);
         d->cachedMetaObject = true;
         for (QHash<QUuid, QAxEventSink*>::Iterator it = d->eventSink.begin(); it != d->eventSink.end(); ++it) {
             QAxEventSink *sink = it.value();
             if (sink) {
                 QUuid ciid = sink->connectionInterface();
 
                 d->metaobj->connectionInterfaces.append(ciid);
                 d->metaobj->sigs.insert(ciid, sink->signalMap());
                 d->metaobj->props.insert(ciid, sink->propertyMap());
                 d->metaobj->propsigs.insert(ciid, sink->propSignalMap());
             }
         }
     }
 
     return metaobj;
 }

◆ paramList()

QList<QByteArray> MetaObjectGenerator::paramList ( const QByteArray & proto )

inlineprivate

Definition at line 1562 of file qaxbase.cpp.

     {
         QByteArray prototype(proto);
         QByteArray parameters = prototype.mid(prototype.indexOf('(') + 1);
         parameters.truncate(parameters.length() - 1);
 
         QList<QByteArray> plist = parameters.split(',');
         return plist;
     }

◆ propertyType()

QByteArray MetaObjectGenerator::propertyType ( const QByteArray & name )

inlineprivate

Definition at line 1711 of file qaxbase.cpp.

Referenced by addSetterSlot().

     {
         return property_list.value(name).type;
     }

◆ readClassInfo()

void MetaObjectGenerator::readClassInfo ( )

Definition at line 2135 of file qaxbase.cpp.

Referenced by QAxBase::connectNotify(), metaObject(), and MetaObjectGenerator().

 {
     // Read class information
     IProvideClassInfo *provideClassInfo = 0;
     if (d)
         d->ptr->QueryInterface(IID_IProvideClassInfo, (void**)&provideClassInfo);
     if (provideClassInfo) {
         provideClassInfo->GetClassInfo(&classInfo);
         TYPEATTR *typeattr = 0;
         if (classInfo)
             classInfo->GetTypeAttr(&typeattr);
 
         QString coClassID;
         if (typeattr) {
             QUuid clsid(typeattr->guid);
             coClassID = clsid.toString().toUpper();
 #ifndef QAX_NO_CLASSINFO
             // UUID
             if (d->useClassInfo && !hasClassInfo("CoClass")) {
                 QString coClassIDstr = iidnames.value(QLatin1String("/CLSID/") + coClassID + QLatin1String("/Default"), coClassID).toString();
                 addClassInfo("CoClass", coClassIDstr.isEmpty() ? coClassID.toLatin1() : coClassIDstr.toLatin1());
                 QByteArray version = QByteArray::number(typeattr->wMajorVerNum) + '.' + QByteArray::number(typeattr->wMinorVerNum);
                 if (version != "0.0")
                     addClassInfo("Version", version);
             }
 #endif
             classInfo->ReleaseTypeAttr(typeattr);
         }
         provideClassInfo->Release();
         provideClassInfo = 0;
 
         if (d->tryCache && !coClassID.isEmpty())
             cacheKey = QString::fromLatin1("%1$%2$%3$%4").arg(coClassID)
                 .arg((int)d->useEventSink).arg((int)d->useClassInfo).arg((int)qax_dispatchEqualsIDispatch);
     }
 
     UINT index = 0;
     if (disp && !dispInfo)
         disp->GetTypeInfo(index, LOCALE_USER_DEFAULT, &dispInfo);
 
     if (dispInfo && !typelib)
         dispInfo->GetContainingTypeLib(&typelib, &index);
 
     if (!typelib) {
         QSettings controls(QLatin1String("HKEY_LOCAL_MACHINE\\Software"), QSettings::NativeFormat);
         QString tlid = controls.value(QLatin1String("/Classes/CLSID/") + that->control() + QLatin1String("/TypeLib/.")).toString();
         QString tlfile;
         if (!tlid.isEmpty()) {
             controls.beginGroup(QLatin1String("/Classes/TypeLib/") + tlid);
             QStringList versions = controls.childGroups();
             QStringList::Iterator vit = versions.begin();
             while (tlfile.isEmpty() && vit != versions.end()) {
                 QString version = *vit;
                 ++vit;
                 tlfile = controls.value(QLatin1Char('/') + version + QLatin1String("/0/win32/.")).toString();
             }
             controls.endGroup();
         } else {
             tlfile = controls.value(QLatin1String("/Classes/CLSID/") + that->control() + QLatin1String("/InprocServer32/.")).toString();
             if (tlfile.isEmpty())
                 tlfile = controls.value(QLatin1String("/Classes/CLSID/") + that->control() + QLatin1String("/LocalServer32/.")).toString();
         }
         if (!tlfile.isEmpty()) {
             LoadTypeLib((OLECHAR*)tlfile.utf16(), &typelib);
             if (!typelib) {
                 tlfile = tlfile.left(tlfile.lastIndexOf(QLatin1Char('.'))) + QLatin1String(".tlb");
                 LoadTypeLib((OLECHAR*)tlfile.utf16(), &typelib);
             }
             if (!typelib) {
                 tlfile = tlfile.left(tlfile.lastIndexOf(QLatin1Char('.'))) + QLatin1String(".olb");
                 LoadTypeLib((OLECHAR*)tlfile.utf16(), &typelib);
             }
         }
     }
 
     if (!classInfo && typelib && that)
         typelib->GetTypeInfoOfGuid(QUuid(that->control()), &classInfo);
 
     if (classInfo && !dispInfo) {
         TYPEATTR *classAttr;
         classInfo->GetTypeAttr(&classAttr);
         if (classAttr) {
             for (int i = 0; i < classAttr->cImplTypes; ++i) {
                 int typeFlags = 0;
                 classInfo->GetImplTypeFlags(i, &typeFlags);
                 if (typeFlags & IMPLTYPEFLAG_FSOURCE)
                     continue;
 
                 HREFTYPE hrefType;
                 if (S_OK == classInfo->GetRefTypeOfImplType(i, &hrefType))
                     classInfo->GetRefTypeInfo(hrefType, &dispInfo);
                 if (dispInfo) {
                     TYPEATTR *ifaceAttr;
                     dispInfo->GetTypeAttr(&ifaceAttr);
                     WORD typekind = ifaceAttr->typekind;
                     dispInfo->ReleaseTypeAttr(ifaceAttr);
 
                     if (typekind & TKIND_DISPATCH) {
                         break;
                     } else {
                         dispInfo->Release();
                         dispInfo = 0;
                     }
                 }
             }
             classInfo->ReleaseTypeAttr(classAttr);
         }
     }
 
     if (!d || !dispInfo || !cacheKey.isEmpty() || !d->tryCache)
         return;
 
     TYPEATTR *typeattr = 0;
     dispInfo->GetTypeAttr(&typeattr);
 
     QString interfaceID;
     if (typeattr) {
         QUuid iid(typeattr->guid);
         interfaceID = iid.toString().toUpper();
 
         dispInfo->ReleaseTypeAttr(typeattr);
         // ### event interfaces!!
         if (!interfaceID.isEmpty())
             cacheKey = QString::fromLatin1("%1$%2$%3$%4").arg(interfaceID)
                 .arg((int)d->useEventSink).arg((int)d->useClassInfo).arg((int)qax_dispatchEqualsIDispatch);
     }
 }

◆ readEnumInfo()

void MetaObjectGenerator::readEnumInfo ( )

Definition at line 2263 of file qaxbase.cpp.

Referenced by QAxBase::connectNotify(), metaObject(), qax_readClassInfo(), qax_readEnumInfo(), and qax_readInterfaceInfo().

 {
     if (!typelib)
         return;
 
     QUuid libUuid;
 
     if (d && d->tryCache) {
         TLIBATTR *libAttr = 0;
         typelib->GetLibAttr(&libAttr);
         if (libAttr) {
             libUuid = QUuid(libAttr->guid);
             typelib->ReleaseTLibAttr(libAttr);
             enum_list = enum_cache.value(libUuid);
             if (!enum_list.isEmpty())
                 return;
         }
     }
 
     int valueindex = 0;
     QSet<QString> clashCheck;
     int clashIndex = 0;
 
     int enum_serial = 0;
     UINT index = typelib->GetTypeInfoCount();
     for (UINT i = 0; i < index; ++i) {
         TYPEKIND typekind;
         typelib->GetTypeInfoType(i, &typekind);
         if (typekind == TKIND_ENUM) {
             // Get the type information for the enum
             ITypeInfo *enuminfo = 0;
             typelib->GetTypeInfo(i, &enuminfo);
             if (!enuminfo)
                 continue;
 
             // Get the name of the enumeration
             BSTR enumname;
             QByteArray enumName;
             if (typelib->GetDocumentation(i, &enumname, 0, 0, 0) == S_OK) {
                 enumName = QString::fromWCharArray(enumname).toLatin1();
                 SysFreeString(enumname);
             } else {
                 enumName = "enum" + QByteArray::number(++enum_serial);
             }
 
             // Get the attributes of the enum type
             TYPEATTR *typeattr = 0;
             enuminfo->GetTypeAttr(&typeattr);
             if (typeattr) {
                 // Get all values of the enumeration
                 for (UINT vd = 0; vd < (UINT)typeattr->cVars; ++vd) {
                     VARDESC *vardesc = 0;
                     enuminfo->GetVarDesc(vd, &vardesc);
                     if (vardesc && vardesc->varkind == VAR_CONST) {
                         int value = vardesc->lpvarValue->lVal;
                         int memid = vardesc->memid;
                         // Get the name of the value
                         BSTR valuename;
                         QByteArray valueName;
                         UINT maxNamesOut;
                         enuminfo->GetNames(memid, &valuename, 1, &maxNamesOut);
                         if (maxNamesOut) {
                             valueName = QString::fromWCharArray(valuename).toLatin1();
                             SysFreeString(valuename);
                         } else {
                             valueName = "value" + QByteArray::number(valueindex++);
                         }
 
                         if (clashCheck.contains(QString::fromLatin1(valueName)))
                             valueName += QByteArray::number(++clashIndex);
 
                         clashCheck.insert(QString::fromLatin1(valueName));
                         addEnumValue(enumName, valueName, value);
                     }
                     enuminfo->ReleaseVarDesc(vardesc);
                 }
             }
             enuminfo->ReleaseTypeAttr(typeattr);
             enuminfo->Release();
         }
     }
 
     if (!libUuid.isNull())
         enum_cache.insert(libUuid, enum_list);
 }

◆ readEventInfo()

void MetaObjectGenerator::readEventInfo ( )

Definition at line 2855 of file qaxbase.cpp.

Referenced by metaObject().

 {
     int event_serial = 0;
     IConnectionPointContainer *cpoints = 0;
     if (d && d->useEventSink)
         d->ptr->QueryInterface(IID_IConnectionPointContainer, (void**)&cpoints);
     if (cpoints) {
         // Get connection point enumerator
         IEnumConnectionPoints *epoints = 0;
         cpoints->EnumConnectionPoints(&epoints);
         if (epoints) {
             ULONG c = 1;
             IConnectionPoint *cpoint = 0;
             epoints->Reset();
             QList<QUuid> cpointlist;
             do {
                 if (cpoint) cpoint->Release();
                 cpoint = 0;
                 HRESULT hr = epoints->Next(c, &cpoint, &c);
                 if (!c || hr != S_OK)
                     break;
 
                 IID conniid;
                 cpoint->GetConnectionInterface(&conniid);
                 // workaround for typelibrary bug of Word.Application
                 QUuid connuuid(conniid);
                 if (cpointlist.contains(connuuid))
                     break;
 
 #ifndef QAX_NO_CLASSINFO
                 if (d->useClassInfo) {
                     QString uuidstr = connuuid.toString().toUpper();
                     uuidstr = iidnames.value(QLatin1String("/Interface/") + uuidstr + QLatin1String("/Default"), uuidstr).toString();
                     addClassInfo("Event Interface " + QByteArray::number(++event_serial), uuidstr.toLatin1());
                 }
 #endif
 
                 // get information about type
                 if (conniid == IID_IPropertyNotifySink) {
                     // test whether property notify sink has been created already, and advise on it
                     QAxEventSink *eventSink = d->eventSink.value(iid_propNotifySink);
                     if (eventSink)
                         eventSink->advise(cpoint, conniid);
                     continue;
                 }
 
                 ITypeInfo *eventinfo = 0;
                 if (typelib)
                     typelib->GetTypeInfoOfGuid(conniid, &eventinfo);
 
                 if (eventinfo) {
                     // avoid recursion (see workaround above)
                     cpointlist.append(connuuid);
 
                     readEventInterface(eventinfo, cpoint);
                     eventinfo->Release();
                 }
             } while (c);
             if (cpoint) cpoint->Release();
             epoints->Release();
         } else if (classInfo) { // no enumeration - search source interfaces and ask for those
         TYPEATTR *typeattr = 0;
         classInfo->GetTypeAttr(&typeattr);
             if (typeattr) {
                 for (int i = 0; i < typeattr->cImplTypes; ++i) {
                     int flags = 0;
                     classInfo->GetImplTypeFlags(i, &flags);
                     if (!(flags & IMPLTYPEFLAG_FSOURCE))
                         continue;
                     HREFTYPE reference;
                     if (S_OK != classInfo->GetRefTypeOfImplType(i, &reference))
                         continue;
                     ITypeInfo *eventInfo = 0;
                     classInfo->GetRefTypeInfo(reference, &eventInfo);
                     if (!eventInfo)
                         continue;
                     TYPEATTR *eventattr = 0;
                     eventInfo->GetTypeAttr(&eventattr);
                     if (eventattr) {
                         IConnectionPoint *cpoint = 0;
                         cpoints->FindConnectionPoint(eventattr->guid, &cpoint);
                         if (cpoint) {
                             if (eventattr->guid == IID_IPropertyNotifySink) {
                                 // test whether property notify sink has been created already, and advise on it
                                 QAxEventSink *eventSink = d->eventSink.value(iid_propNotifySink);
                                 if (eventSink)
                                     eventSink->advise(cpoint, eventattr->guid);
                                 continue;
                             }
 
                             readEventInterface(eventInfo, cpoint);
                             cpoint->Release();
                         }
                         eventInfo->ReleaseTypeAttr(eventattr);
                     }
                     eventInfo->Release();
                 }
                 classInfo->ReleaseTypeAttr(typeattr);
             }
         }
         cpoints->Release();
     }
 }

◆ readEventInterface()

void MetaObjectGenerator::readEventInterface	(	ITypeInfo *	eventinfo,
		IConnectionPoint *	cpoint
	)

Definition at line 2772 of file qaxbase.cpp.

Referenced by QAxBase::connectNotify(), qax_readClassInfo(), and readEventInfo().

 {
     TYPEATTR *eventattr;
     eventinfo->GetTypeAttr(&eventattr);
     if (!eventattr)
         return;
     if (eventattr->typekind != TKIND_DISPATCH) {
         eventinfo->ReleaseTypeAttr(eventattr);
         return;
     }
 
     QAxEventSink *eventSink = 0;
     if (d) {
         IID conniid;
         cpoint->GetConnectionInterface(&conniid);
         eventSink = d->eventSink.value(QUuid(conniid));
         if (!eventSink) {
             eventSink = new QAxEventSink(that);
             d->eventSink.insert(QUuid(conniid), eventSink);
             eventSink->advise(cpoint, conniid);
         }
     }
 
     // get information about all event functions
     for (UINT fd = 0; fd < (UINT)eventattr->cFuncs; ++fd) {
         FUNCDESC *funcdesc;
         eventinfo->GetFuncDesc(fd, &funcdesc);
         if (!funcdesc)
             break;
         if (funcdesc->invkind != INVOKE_FUNC ||
             funcdesc->funckind != FUNC_DISPATCH) {
             eventinfo->ReleaseTypeAttr(eventattr);
             eventinfo->ReleaseFuncDesc(funcdesc);
             continue;
         }
 
         QByteArray function;
         QByteArray prototype;
         QList<QByteArray> parameters;
 
         // parse event function description
         BSTR bstrNames[256];
         UINT maxNames = 255;
         UINT maxNamesOut;
         eventinfo->GetNames(funcdesc->memid, (BSTR*)&bstrNames, maxNames, &maxNamesOut);
         QList<QByteArray> names;
         int p;
         for (p = 0; p < (int)maxNamesOut; ++p) {
             names << QString::fromWCharArray(bstrNames[p]).toLatin1();
             SysFreeString(bstrNames[p]);
         }
 
         // get event function prototype
         function = names.at(0);
         QByteArray type; // dummy - we don't care about return values for signals
         prototype = createPrototype(/*in*/ funcdesc, eventinfo, names, /*out*/type, parameters);
         if (!hasSignal(prototype)) {
             QByteArray pnames;
             for (p = 0; p < parameters.count(); ++p) {
                 pnames += parameters.at(p);
                 if (p < parameters.count() - 1)
                     pnames += ',';
             }
             addSignal(prototype, pnames);
         }
         if (eventSink)
             eventSink->addSignal(funcdesc->memid, prototype);
 
 #if 0 // documentation in metaobject would be cool?
         // get function documentation
         BSTR bstrDocu;
         eventinfo->GetDocumentation(funcdesc->memid, 0, &bstrDocu, 0, 0);
         QString strDocu = QString::fromWCharArray(bstrDocu);
         SysFreeString(bstrDocu);
         if (!!strDocu)
             desc += '[' + strDocu + ']';
         desc += '\n';
 #endif
         eventinfo->ReleaseFuncDesc(funcdesc);
     }
     eventinfo->ReleaseTypeAttr(eventattr);
 }

◆ readFuncsInfo()

void MetaObjectGenerator::readFuncsInfo	(	ITypeInfo *	typeinfo,
		ushort	nFuncs
	)

Definition at line 2451 of file qaxbase.cpp.

Referenced by qax_readClassInfo(), qax_readInterfaceInfo(), and readInterfaceInfo().

 {
     if (!nFuncs) {
         TYPEATTR *typeattr = 0;
         typeinfo->GetTypeAttr(&typeattr);
         if (typeattr) {
             nFuncs = typeattr->cFuncs;
             typeinfo->ReleaseTypeAttr(typeattr);
         }
     }
 
     // get information about all functions
     for (ushort fd = 0; fd < nFuncs ; ++fd) {
         FUNCDESC *funcdesc = 0;
         typeinfo->GetFuncDesc(fd, &funcdesc);
         if (!funcdesc)
             break;
 
         QByteArray function;
         QByteArray type;
         QByteArray prototype;
         QList<QByteArray> parameters;
 
         // parse function description
         BSTR bstrNames[256];
         UINT maxNames = 255;
         UINT maxNamesOut;
         typeinfo->GetNames(funcdesc->memid, (BSTR*)&bstrNames, maxNames, &maxNamesOut);
         QList<QByteArray> names;
         int p;
         for (p = 0; p < (int)maxNamesOut; ++p) {
             names << QString::fromWCharArray(bstrNames[p]).toLatin1();
             SysFreeString(bstrNames[p]);
         }
 
         // function name
         function = names.at(0);
         if ((maxNamesOut == 3 && function == "QueryInterface") ||
             (maxNamesOut == 1 && function == "AddRef") ||
             (maxNamesOut == 1 && function == "Release") ||
             (maxNamesOut == 9 && function == "Invoke") ||
             (maxNamesOut == 6 && function == "GetIDsOfNames") ||
             (maxNamesOut == 2 && function == "GetTypeInfoCount") ||
             (maxNamesOut == 4 && function == "GetTypeInfo")) {
             typeinfo->ReleaseFuncDesc(funcdesc);
             continue;
         }
 
         prototype = createPrototype(/*in*/ funcdesc, typeinfo, names, /*out*/type, parameters);
 
         // get type of function
         switch(funcdesc->invkind) {
         case INVOKE_PROPERTYGET: // property
         case INVOKE_PROPERTYPUT:
             if (funcdesc->cParams - funcdesc->cParamsOpt <= 1) {
                 bool dontBreak = false;
                 // getter with non-default-parameters -> fall through to function handling
                 if (funcdesc->invkind == INVOKE_PROPERTYGET && parameters.count() && funcdesc->cParams - funcdesc->cParamsOpt) {
                     dontBreak = true;
                 } else {
                     uint flags = Readable;
                     if (funcdesc->invkind != INVOKE_PROPERTYGET)
                         flags |= Writable;
                     if (!(funcdesc->wFuncFlags & (FUNCFLAG_FNONBROWSABLE | FUNCFLAG_FHIDDEN)))
                         flags |= Designable;
                     if (!(funcdesc->wFuncFlags & FUNCFLAG_FRESTRICTED))
                         flags |= Scriptable;
                     if (funcdesc->wFuncFlags & FUNCFLAG_FREQUESTEDIT)
                         flags |= RequestingEdit;
                     if (hasEnum(type))
                         flags |= EnumOrFlag;
 
                     if (funcdesc->wFuncFlags & FUNCFLAG_FBINDABLE && funcdesc->invkind == INVOKE_PROPERTYGET) {
                         addChangedSignal(function, type, funcdesc->memid);
                         flags |= Bindable;
                     }
                     // Don't generate code for properties without type
                     if (type.isEmpty())
                         break;
                     addProperty(type, function, flags);
 
                     // more parameters -> function handling
                     if (funcdesc->invkind == INVOKE_PROPERTYGET && funcdesc->cParams)
                         dontBreak = true;
                 }
 
                 if (!funcdesc->cParams) {
                     // don't generate slots for incomplete properties
                     if (type.isEmpty())
                         break;
 
                     // Done for getters
                     if (funcdesc->invkind == INVOKE_PROPERTYGET)
                         break;
 
                     // generate setter slot
                     if (funcdesc->invkind == INVOKE_PROPERTYPUT && hasProperty(function)) {
                         addSetterSlot(function);
                         break;
                     }
                 } else if (funcdesc->invkind == INVOKE_PROPERTYPUT && hasProperty(function)) {
                     addSetterSlot(function);
                     // more parameters -> function handling
                     if (funcdesc->cParams > 1)
                         dontBreak = true;
                 }
                 if (!dontBreak)
                     break;
             }
             if (funcdesc->invkind == INVOKE_PROPERTYPUT) {
                 // remove the typename guessed for property setters
                 // its done only for setter's with more than one parameter.
                 if (funcdesc->cParams - funcdesc->cParamsOpt > 1) {
                     type.clear();
                 }
                 QByteArray set;
                 if (isupper(prototype.at(0))) {
                     set = "Set";
                 } else {
                     set = "set";
                     prototype[0] = toupper(prototype[0]);
                 }
 
                 prototype = set + prototype;
             }
             // FALL THROUGH to support multi-variat properties
         case INVOKE_FUNC: // method
             {
                 bool cloned = false;
                 bool defargs;
                 do {
                     QByteArray pnames;
                     for (p = 0; p < parameters.count(); ++p) {
                         pnames += parameters.at(p);
                         if (p < parameters.count() - 1)
                             pnames += ',';
                     }
                     defargs = pnames.contains("=0");
                     int flags = QMetaMethod::Public;
                     if (cloned)
                         flags |= QMetaMethod::Cloned << 4;
                     cloned |= defargs;
                     addSlot(type, prototype, pnames.replace("=0", ""), flags);
 
                     if (defargs) {
                         parameters.takeLast();
                         int lastParam = prototype.lastIndexOf(',');
                         if (lastParam == -1)
                             lastParam = prototype.indexOf('(') + 1;
                         prototype.truncate(lastParam);
                         prototype += ')';
                     }
                 } while (defargs);
             }
             break;
 
         default:
             break;
         }
 #if 0 // documentation in metaobject would be cool?
         // get function documentation
         BSTR bstrDocu;
         info->GetDocumentation(funcdesc->memid, 0, &bstrDocu, 0, 0);
         QString strDocu = QString::fromWCharArray(bstrDocu);
         SysFreeString(bstrDocu);
         if (!!strDocu)
             desc += '[' + strDocu + ']';
         desc += '\n';
 #endif
         typeinfo->ReleaseFuncDesc(funcdesc);
     }
 }

◆ readInterfaceInfo()

void MetaObjectGenerator::readInterfaceInfo ( )

Definition at line 2707 of file qaxbase.cpp.

Referenced by metaObject().

 {
     ITypeInfo *typeinfo = dispInfo;
     if (!typeinfo)
         return;
     typeinfo->AddRef();
     int interface_serial = 0;
     while (typeinfo) {
         ushort nFuncs = 0;
         ushort nVars = 0;
         ushort nImpl = 0;
         // get information about type
         TYPEATTR *typeattr;
         typeinfo->GetTypeAttr(&typeattr);
         bool interesting = true;
         if (typeattr) {
             // get number of functions, variables, and implemented interfaces
             nFuncs = typeattr->cFuncs;
             nVars = typeattr->cVars;
             nImpl = typeattr->cImplTypes;
 
             if ((typeattr->typekind == TKIND_DISPATCH || typeattr->typekind == TKIND_INTERFACE) &&
                 (typeattr->guid != IID_IDispatch && typeattr->guid != IID_IUnknown)) {
 #ifndef QAX_NO_CLASSINFO
                 if (d && d->useClassInfo) {
                     // UUID
                     QUuid uuid(typeattr->guid);
                     QString uuidstr = uuid.toString().toUpper();
                     uuidstr = iidnames.value(QLatin1String("/Interface/") + uuidstr + QLatin1String("/Default"), uuidstr).toString();
                     addClassInfo("Interface " + QByteArray::number(++interface_serial), uuidstr.toLatin1());
                 }
 #endif
                 typeinfo->ReleaseTypeAttr(typeattr);
             } else {
                 interesting = false;
                 typeinfo->ReleaseTypeAttr(typeattr);
             }
         }
 
         if (interesting) {
             readFuncsInfo(typeinfo, nFuncs);
             readVarsInfo(typeinfo, nVars);
         }
 
         if (!nImpl) {
             typeinfo->Release();
             typeinfo = 0;
             break;
         }
 
         // go up one base class
         HREFTYPE pRefType;
         typeinfo->GetRefTypeOfImplType(0, &pRefType);
         ITypeInfo *baseInfo = 0;
         typeinfo->GetRefTypeInfo(pRefType, &baseInfo);
         typeinfo->Release();
         if (typeinfo == baseInfo) { // IUnknown inherits IUnknown ???
             baseInfo->Release();
             typeinfo = 0;
             break;
         }
         typeinfo = baseInfo;
     }
 }

◆ readVarsInfo()

void MetaObjectGenerator::readVarsInfo	(	ITypeInfo *	typeinfo,
		ushort	nVars
	)

Definition at line 2624 of file qaxbase.cpp.

Referenced by qax_readClassInfo(), qax_readInterfaceInfo(), and readInterfaceInfo().

 {
     if (!nVars) {
         TYPEATTR *typeattr = 0;
         typeinfo->GetTypeAttr(&typeattr);
         if (typeattr) {
             nVars = typeattr->cVars;
             typeinfo->ReleaseTypeAttr(typeattr);
         }
     }
 
     // get information about all variables
     for (ushort vd = 0; vd < nVars; ++vd) {
         VARDESC *vardesc;
         typeinfo->GetVarDesc(vd, &vardesc);
         if (!vardesc)
             break;
 
         // no use if it's not a dispatched variable
         if (vardesc->varkind != VAR_DISPATCH) {
             typeinfo->ReleaseVarDesc(vardesc);
             continue;
         }
 
         // get variable name
         BSTR bstrName;
         UINT maxNames = 1;
         UINT maxNamesOut;
         typeinfo->GetNames(vardesc->memid, &bstrName, maxNames, &maxNamesOut);
         if (maxNamesOut != 1 || !bstrName) {
             typeinfo->ReleaseVarDesc(vardesc);
             continue;
         }
         QByteArray variableType;
         QByteArray variableName;
         uint flags = 0;
 
         variableName = QString::fromWCharArray(bstrName).toLatin1();
         SysFreeString(bstrName);
 
         // get variable type
         TYPEDESC typedesc = vardesc->elemdescVar.tdesc;
         variableType = guessTypes(typedesc, typeinfo, variableName);
 
         // generate meta property
         if (!hasProperty(variableName)) {
             flags = Readable;
             if (!(vardesc->wVarFlags & VARFLAG_FREADONLY))
                 flags |= Writable;
             if (!(vardesc->wVarFlags & (VARFLAG_FNONBROWSABLE | VARFLAG_FHIDDEN)))
                 flags |= Designable;
             if (!(vardesc->wVarFlags & VARFLAG_FRESTRICTED))
                 flags |= Scriptable;
             if (vardesc->wVarFlags & VARFLAG_FREQUESTEDIT)
                 flags |= RequestingEdit;
             if (hasEnum(variableType))
                 flags |= EnumOrFlag;
 
             if (vardesc->wVarFlags & VARFLAG_FBINDABLE) {
                 addChangedSignal(variableName, variableType, vardesc->memid);
                 flags |= Bindable;
             }
             addProperty(variableType, variableName, flags);
         }
 
         // generate a set slot
         if (!(vardesc->wVarFlags & VARFLAG_FREADONLY))
             addSetterSlot(variableName);
 
 #if 0 // documentation in metaobject would be cool?
         // get function documentation
         BSTR bstrDocu;
         info->GetDocumentation(vardesc->memid, 0, &bstrDocu, 0, 0);
         QString strDocu = QString::fromWCharArray(bstrDocu);
         SysFreeString(bstrDocu);
         if (!!strDocu)
             desc += '[' + strDocu + ']';
         desc += '\n';
 #endif
         typeinfo->ReleaseVarDesc(vardesc);
     }
 }

◆ replacePrototype()

QByteArray MetaObjectGenerator::replacePrototype ( const QByteArray & prototype )

inlineprivate

Definition at line 1588 of file qaxbase.cpp.

     {
         QByteArray proto(prototype);
 
         QList<QByteArray> plist = paramList(prototype);
         for (int p = 0; p < plist.count(); ++p) {
             QByteArray param(plist.at(p));
             if (param != replaceType(param)) {
                 int type = 0;
                 while (type_conversion[type][0]) {
                     int paren = proto.indexOf('(');
                     while ((paren = proto.indexOf(type_conversion[type][0])) != -1) {
                         proto.replace(paren, qstrlen(type_conversion[type][0]), type_conversion[type][1]);
                     }
                     ++type;
                 }
                 break;
             }
         }
 
         return proto;
     }

◆ replaceType()

QByteArray MetaObjectGenerator::replaceType ( const QByteArray & type )

inlineprivate

Definition at line 1572 of file qaxbase.cpp.

Referenced by addChangedSignal().

     {
         int i = 0;
         while (type_conversion[i][0]) {
             int len = int(strlen(type_conversion[i][0]));
             int ti;
             if ((ti = type.indexOf(type_conversion[i][0])) != -1) {
                 QByteArray rtype(type);
                 rtype.replace(ti, len, type_conversion[i][1]);
                 return rtype;
             }
             ++i;
         }
         return type;
     }

◆ tryCache()

QMetaObject * MetaObjectGenerator::tryCache ( )

private

Definition at line 2959 of file qaxbase.cpp.

Referenced by metaObject().

 {
     if (!cacheKey.isEmpty()) {
         d->metaobj = mo_cache.value(cacheKey);
         if (d->metaobj) {
             d->cachedMetaObject = true;
 
             IConnectionPointContainer *cpoints = 0;
             d->ptr->QueryInterface(IID_IConnectionPointContainer, (void**)&cpoints);
             if (cpoints) {
                 QList<QUuid>::ConstIterator it = d->metaobj->connectionInterfaces.begin();
                 while (it != d->metaobj->connectionInterfaces.end()) {
                     QUuid iid = *it;
                     ++it;
 
                     IConnectionPoint *cpoint = 0;
                     cpoints->FindConnectionPoint(iid, &cpoint);
                     if (cpoint) {
                         QAxEventSink *sink = new QAxEventSink(that);
                         sink->advise(cpoint, iid);
                         d->eventSink.insert(iid, sink);
                         sink->sigs = d->metaobj->sigs.value(iid);
                         sink->props = d->metaobj->props.value(iid);
                         sink->propsigs = d->metaobj->propsigs.value(iid);
                         cpoint->Release();
                     }
                 }
                 cpoints->Release();
             }
 
             return d->metaobj;
         }
     }
     return 0;
 }

◆ usertypeToString()

QByteArray MetaObjectGenerator::usertypeToString	(	const TYPEDESC &	tdesc,
		ITypeInfo *	info,
		const QByteArray &	function
	)

private

Definition at line 1889 of file qaxbase.cpp.

Referenced by guessTypes().

 {
     HREFTYPE usertype = tdesc.hreftype;
     if (tdesc.vt != VT_USERDEFINED)
         return 0;
 
     QByteArray typeName;
     ITypeInfo *usertypeinfo = 0;
     info->GetRefTypeInfo(usertype, &usertypeinfo);
     if (usertypeinfo) {
         ITypeLib *usertypelib = 0;
         UINT index;
         usertypeinfo->GetContainingTypeLib(&usertypelib, &index);
         if (usertypelib) {
             // get type library name
             BSTR typelibname = 0;
             usertypelib->GetDocumentation(-1, &typelibname, 0, 0, 0);
             QByteArray typeLibName = QString::fromWCharArray(typelibname).toLatin1();
             SysFreeString(typelibname);
 
             // get type name
             BSTR usertypename = 0;
             usertypelib->GetDocumentation(index, &usertypename, 0, 0, 0);
             QByteArray userTypeName = QString::fromWCharArray(usertypename).toLatin1();
             SysFreeString(usertypename);
 
             if (hasEnum(userTypeName)) // known enum?
                 typeName = userTypeName;
             else if (userTypeName == "OLE_COLOR" || userTypeName == "VB_OLE_COLOR")
                 typeName = "QColor";
             else if (userTypeName == "IFontDisp" || userTypeName == "IFontDisp*" || userTypeName == "IFont" || userTypeName == "IFont*")
                 typeName = "QFont";
             else if (userTypeName == "Picture" || userTypeName == "Picture*")
                 typeName = "QPixmap";
 
             if (typeName.isEmpty()) {
                 TYPEATTR *typeattr = 0;
                 usertypeinfo->GetTypeAttr(&typeattr);
                 if (typeattr) {
                     switch(typeattr->typekind) {
                     case TKIND_ALIAS:
                         userTypeName = guessTypes(typeattr->tdescAlias, usertypeinfo, function);
                         break;
                     case TKIND_DISPATCH:
                     case TKIND_COCLASS:
                         if (qax_dispatchEqualsIDispatch) {
                             userTypeName = "IDispatch";
                         } else {
                             if (typeLibName != current_typelib)
                                 userTypeName = typeLibName + "::" + userTypeName;
                             if (!qax_qualified_usertypes.contains(userTypeName))
                                 qax_qualified_usertypes << userTypeName;
                         }
                         break;
                     case TKIND_ENUM:
                         if (typeLibName != current_typelib)
                             userTypeName = typeLibName + "::" + userTypeName;
                         if (!qax_qualified_usertypes.contains("enum " + userTypeName))
                             qax_qualified_usertypes << "enum " + userTypeName;
                         break;
                     case TKIND_INTERFACE:
                         if (typeLibName != current_typelib)
                             userTypeName = typeLibName + "::" + userTypeName;
                         if (!qax_qualified_usertypes.contains(userTypeName))
                             qax_qualified_usertypes << userTypeName;
                         break;
                     case TKIND_RECORD:
                         if (!qax_qualified_usertypes.contains("struct " + userTypeName))
                             qax_qualified_usertypes << "struct "+ userTypeName;
                         break;
                     default:
                         break;
                     }
                 }
 
                 usertypeinfo->ReleaseTypeAttr(typeattr);
                 typeName = userTypeName;
             }
             usertypelib->Release();
         }
         usertypeinfo->Release();
     }
 
     return typeName;
 }

Friends and Related Functions

◆ qax_readClassInfo

QMetaObject* qax_readClassInfo	(	ITypeLib *	typeLib,
		ITypeInfo *	classInfo,
		const QMetaObject *	parentObject
	)

friend

Definition at line 1772 of file qaxbase.cpp.

 {
     MetaObjectGenerator generator(typeLib, 0);
     generator.addSignal("exception(int,QString,QString,QString)", "code,source,disc,help");
     generator.addSignal("propertyChanged(QString)", "name");
 
     QString className;
     BSTR bstr;
     if (S_OK != classInfo->GetDocumentation(-1, &bstr, 0, 0, 0))
         return 0;
 
     className = QString::fromWCharArray(bstr);
     SysFreeString(bstr);
 
     generator.readEnumInfo();
 
     TYPEATTR *typeattr;
     classInfo->GetTypeAttr(&typeattr);
     if (typeattr) {
         int nInterfaces = typeattr->cImplTypes;
         classInfo->ReleaseTypeAttr(typeattr);
 
         for (int index = 0; index < nInterfaces; ++index) {
             HREFTYPE refType;
             if (S_OK != classInfo->GetRefTypeOfImplType(index, &refType))
                 continue;
 
             int flags = 0;
             classInfo->GetImplTypeFlags(index, &flags);
             if (flags & IMPLTYPEFLAG_FRESTRICTED)
                 continue;
 
             ITypeInfo *interfaceInfo = 0;
             classInfo->GetRefTypeInfo(refType, &interfaceInfo);
             if (!interfaceInfo)
                 continue;
 
             interfaceInfo->GetDocumentation(-1, &bstr, 0, 0, 0);
             QString interfaceName = QString::fromWCharArray(bstr);
             SysFreeString(bstr);
             QByteArray key;
 
             TYPEATTR *typeattr = 0;
             interfaceInfo->GetTypeAttr(&typeattr);
 
             if (flags & IMPLTYPEFLAG_FSOURCE) {
                 if (typeattr && !(typeattr->wTypeFlags & TYPEFLAG_FHIDDEN))
                     key = "Event Interface " + QByteArray::number(index);
                 generator.readEventInterface(interfaceInfo, 0);
             } else {
                 if (typeattr && !(typeattr->wTypeFlags & TYPEFLAG_FHIDDEN))
                     key = "Interface " + QByteArray::number(index);
                 generator.readFuncsInfo(interfaceInfo, 0);
                 generator.readVarsInfo(interfaceInfo, 0);
             }
             if (!key.isEmpty())
                 generator.addClassInfo(key.data(), interfaceName.toLatin1());
 
             if (typeattr)
                 interfaceInfo->ReleaseTypeAttr(typeattr);
             interfaceInfo->Release();
         }
     }
 
     return generator.metaObject(parentObject, className.toLatin1());
 }

Properties

◆ cacheKey

QString MetaObjectGenerator::cacheKey

private

Definition at line 1737 of file qaxbase.cpp.

Referenced by metaObject(), readClassInfo(), and tryCache().

◆ classInfo

ITypeInfo* MetaObjectGenerator::classInfo

private

Definition at line 1732 of file qaxbase.cpp.

Referenced by readClassInfo(), readEventInfo(), and ~MetaObjectGenerator().

◆ classinfo_list

QMap<QByteArray, QByteArray> MetaObjectGenerator::classinfo_list

private

Definition at line 1611 of file qaxbase.cpp.

Referenced by metaObject().

◆ current_typelib

QByteArray MetaObjectGenerator::current_typelib

private

Definition at line 1734 of file qaxbase.cpp.

Referenced by metaObject(), MetaObjectGenerator(), and usertypeToString().

◆ d

QAxBasePrivate* MetaObjectGenerator::d

private

◆ debugInfo

QByteArray MetaObjectGenerator::debugInfo

private

Definition at line 1738 of file qaxbase.cpp.

Referenced by metaObject().

◆ disp

IDispatch* MetaObjectGenerator::disp

private

Definition at line 1730 of file qaxbase.cpp.

Referenced by QAxBase::connectNotify(), QAxBase::dynamicCallHelper(), init(), QAxBase::internalInvoke(), QAxBase::internalProperty(), and readClassInfo().

◆ dispInfo

ITypeInfo* MetaObjectGenerator::dispInfo

private

Definition at line 1731 of file qaxbase.cpp.

Referenced by init(), MetaObjectGenerator(), readClassInfo(), readInterfaceInfo(), and ~MetaObjectGenerator().

◆ enum_list

QMap<QByteArray, QList<QPair<QByteArray, int> > > MetaObjectGenerator::enum_list

private

Definition at line 1716 of file qaxbase.cpp.

Referenced by metaObject(), and readEnumInfo().

◆ iid_propNotifySink

QUuid MetaObjectGenerator::iid_propNotifySink

private

Definition at line 1740 of file qaxbase.cpp.

Referenced by addChangedSignal(), init(), and readEventInfo().

◆ iidnames

QSettings MetaObjectGenerator::iidnames

private

Definition at line 1736 of file qaxbase.cpp.

Referenced by readClassInfo(), readEventInfo(), and readInterfaceInfo().

◆ property_list

QMap<QByteArray, Property> MetaObjectGenerator::property_list

private

Definition at line 1673 of file qaxbase.cpp.

Referenced by metaObject().

◆ signal_list

QMap<QByteArray, Method> MetaObjectGenerator::signal_list

private

Definition at line 1626 of file qaxbase.cpp.

Referenced by metaObject().

◆ slot_list

QMap<QByteArray, Method> MetaObjectGenerator::slot_list

private

Definition at line 1646 of file qaxbase.cpp.

Referenced by metaObject().

◆ that

QAxBase* MetaObjectGenerator::that

private

Definition at line 1727 of file qaxbase.cpp.

Referenced by addChangedSignal(), metaObject(), readClassInfo(), readEventInterface(), and tryCache().

◆ typelib

ITypeLib* MetaObjectGenerator::typelib

private

Definition at line 1733 of file qaxbase.cpp.

Referenced by QAxBase::connectNotify(), metaObject(), MetaObjectGenerator(), readClassInfo(), readEnumInfo(), readEventInfo(), and ~MetaObjectGenerator().

The documentation for this class was generated from the following file:

/src/activeqt/container/qaxbase.cpp

Classes

Public Functions

Private Types

Private Functions

Properties

Friends

Detailed Description

Enumerations

◆ MemberFlags

◆ ProperyFlags

Constructors and Destructors

◆ MetaObjectGenerator() [1/2]

◆ MetaObjectGenerator() [2/2]

◆ ~MetaObjectGenerator()

Functions

◆ addChangedSignal()

◆ addClassInfo()

◆ addEnumValue()

◆ addProperty()

◆ addSetterSlot()

◆ addSignal()

◆ addSlot()

◆ createPrototype()

◆ guessTypes()

◆ hasClassInfo()

◆ hasEnum()

◆ hasProperty()

◆ hasSignal()

◆ hasSlot()

◆ init()

◆ metaObject()

◆ paramList()

◆ propertyType()

◆ readClassInfo()

◆ readEnumInfo()

◆ readEventInfo()

◆ readEventInterface()

◆ readFuncsInfo()

◆ readInterfaceInfo()

◆ readVarsInfo()

◆ replacePrototype()

◆ replaceType()

◆ tryCache()

◆ usertypeToString()

Friends and Related Functions

◆ qax_readClassInfo

Properties

◆ cacheKey

◆ classInfo

◆ classinfo_list

◆ current_typelib

◆ d

◆ debugInfo

◆ disp

◆ dispInfo

◆ enum_list

◆ iid_propNotifySink

◆ iidnames

◆ property_list

◆ signal_list

◆ slot_list

◆ that

◆ typelib