QSet<QString> operatorCodes;

AbstractMetaFunctionList returned;

AbstractMetaFunctionList functions = cls->functions();

foreach (AbstractMetaFunction *function, functions) {

if (function->originalName().startsWith("operator")) {

QString op = function->originalName().mid(8);

operatorCodes.insert(op);

}

}

QSet<QString> r;

foreach(QString op, operatorCodes.toList()) {

if (op == ">" || op == "<" || op == ">=" || op == "<=" || op == "==" || op == "!=") {

r.insert("PythonQt::Type_RichCompare");

} else if (op == "+") {

r.insert("PythonQt::Type_Add");

} else if (op == "-") {

r.insert("PythonQt::Type_Subtract");

} else if (op == "/") {

r.insert("PythonQt::Type_Divide");

} else if (op == "*") {

r.insert("PythonQt::Type_Multiply");

} else if (op == "%") {

r.insert("PythonQt::Type_Mod");

} else if (op == "&") {

r.insert("PythonQt::Type_And");

} else if (op == "|") {

r.insert("PythonQt::Type_Or");

} else if (op == "^") {

r.insert("PythonQt::Type_Xor");

} else if (op == "~") {

r.insert("PythonQt::Type_Invert");

} else if (op == "+=") {

r.insert("PythonQt::Type_InplaceAdd");

} else if (op == "-=") {

r.insert("PythonQt::Type_InplaceSubtract");

} else if (op == "/=") {

r.insert("PythonQt::Type_InplaceDivide");

} else if (op == "*=") {

r.insert("PythonQt::Type_InplaceMultiply");

} else if (op == "%=") {

r.insert("PythonQt::Type_InplaceMod");

} else if (op == "&=") {

r.insert("PythonQt::Type_InplaceAnd");

} else if (op == "|=") {

r.insert("PythonQt::Type_InplaceOr");

} else if (op == "^=") {

r.insert("PythonQt::Type_InplaceXor");

}

}

if (cls->hasDefaultIsNull()) {

r.insert("PythonQt::Type_NonZero");

}

{

CodeSnipList code_snips = cls->typeEntry()->codeSnips();

foreach(const CodeSnip &cs, code_snips) {

if (cs.language == TypeSystem::PyWrapperOperators) {

QStringList values = cs.code().split(" ", QString::SkipEmptyParts);

foreach(QString value, values) {

r.insert(value);

}

}

}

}

QStringList result = r.toList();

qSort(result);

return result;

if (type->instantiations().size() > 0) {

QList<AbstractMetaType *> args = type->instantiations();

/*

if (args.count() == 1) {

if (args.at(0)->indirections() > 0) {

return;

}

QString typeName = type->typeEntry()->qualifiedCppName();

QString innerName = args.at(0)->typeEntry()->qualifiedCppName();

if (typeName == "QStringList") {

return;

}

if (typeName.startsWith("QVector") || typeName.startsWith("QList")) {

if (args.at(0)->isEnum()) {

output.insert(QString("PythonQtMethodInfo::addParameterTypeAlias(\"") + typeName + "<" + innerName + ">\", \"" + typeName + "<int>\");");

} else if (args.at(0)->instantiations().isEmpty() && innerName.startsWith("Q") && !_builtinListTypes.contains(innerName)) {

QString result = "PythonQtRegisterListTemplateConverterForKnownClass(" + typeName + ", " + innerName + ");";

output.insert(result);

}

if (!innerName.startsWith("Q")) {

// for debugging:

//output.insert(QString("// POD: ") + typeName + " " + innerName);

}

}

}

}

{

AbstractMetaClassList classes_with_polymorphic_id;

{

QHashIterator<QString, QList<const AbstractMetaClass*> > pack(packHash);

while (pack.hasNext()) {

pack.next();

QList<const AbstractMetaClass*> list = pack.value();

foreach (const AbstractMetaClass *cls, list) {

if (cls->typeEntry()->isPolymorphicBase()) {

classes_with_polymorphic_id.append((AbstractMetaClass*)cls);

}

}

}

}

qSort(classes_with_polymorphic_id.begin(), classes_with_polymorphic_id.end(), class_less_than);

QHashIterator<QString, QList<const AbstractMetaClass*> > pack(packHash);

while (pack.hasNext()) {

pack.next();

QList<const AbstractMetaClass*> list = pack.value();

if (list.isEmpty())

continue;

qSort(list.begin(), list.end(), class_less_than);

QString packKey = pack.key();

QString packName = pack.key();

QStringList components = packName.split("_");

if ((components.size() > 2) && (components.at(0) == "com")

&& (components.at(1) == "trolltech")) {

// kill com.trolltech in key

components.removeAt(0);

components.removeAt(0);

}

QString shortPackName;

foreach (QString comp, components) {

comp[0] = comp[0].toUpper();

shortPackName += comp;

}

// add missing camel case (workaround..)

if (shortPackName == "QtWebkit") {

shortPackName = "QtWebKit";

} else if (shortPackName == "QtXmlpatterns") {

shortPackName = "QtXmlPatterns";

} else if (shortPackName == "QtOpengl") {

shortPackName = "QtOpenGL";

} else if (shortPackName == "QtUitools") {

shortPackName = "QtUiTools";

}

{

QString fileName(packName + "/" + packKey + "_init.cpp");

FileOut initFile(m_out_dir + "/generated_cpp/" + fileName);

ReportHandler::debugSparse(QString("generating: %1").arg(fileName));

QTextStream &s = initFile.stream;

s << "#include <PythonQt.h>" << endl;

s << "#include <PythonQtConversion.h>" << endl;

for (int i=0; i<(list.count()+MAX_CLASSES_PER_FILE-1) / MAX_CLASSES_PER_FILE; i++) {

s << "#include \"" << packKey << QString::number(i) << ".h\"" << endl;

}

s << endl;

QStringList polymorphicHandlers;

if (!packName.endsWith("_builtin")) {

polymorphicHandlers = writePolymorphicHandler(s, list.at(0)->package(), classes_with_polymorphic_id, list);

s << endl;

}

QSet<QString> listRegistration;

QSet<QString> snips;

foreach(const AbstractMetaClass *cls, list) {

Q_FOREACH(const AbstractMetaFunction* func, cls->functions()) {

if (func->type() && func->type()->isContainer()) {

addListRegistration(func->type(), listRegistration);

}

Q_FOREACH(const AbstractMetaArgument* arg, func->arguments()) {

if (arg->type() && arg->type()->isContainer()) {

addListRegistration(arg->type(), listRegistration);

}

}

}

{

while (cls) {

CodeSnipList code_snips = cls->typeEntry()->codeSnips();

foreach(const CodeSnip &cs, code_snips) {

if (cs.language == TypeSystem::PyInitSource) {

snips.insert(cs.code());

}

}

cls = cls->baseClass();

}

}

}

foreach(QString snip, snips) {

s << snip;

}

s << endl;

// declare individual class creation functions

s << "void PythonQt_init_" << shortPackName << "(PyObject* module) {" << endl;

if (shortPackName.endsWith("Builtin")) {

shortPackName = shortPackName.mid(0, shortPackName.length()-strlen("builtin"));

}

foreach (const AbstractMetaClass *cls, list) {

if (cls->qualifiedCppName().contains("Ssl")) {

s << "#ifndef QT_NO_SSL" << endl;

}

AbstractMetaFunctionList ctors = cls->queryFunctions(AbstractMetaClass::Constructors

| AbstractMetaClass::WasVisible

| AbstractMetaClass::NotRemovedFromTargetLang);

QString shellCreator;

if (cls->generateShellClass() && !ctors.isEmpty()) {

QString setInstanceFunc = "PythonQtSetInstanceWrapperOnShell";

{

const AbstractMetaClass* theclass = cls;

while (theclass) {

CodeSnipList code_snips = theclass->typeEntry()->codeSnips();

foreach(const CodeSnip &cs, code_snips) {

if (cs.language == TypeSystem::PySetWrapperFunc) {

setInstanceFunc = cs.code();

break;

}

}

theclass = theclass->baseClass();

}

}

shellCreator = ", " + setInstanceFunc + "<" + ShellGenerator::shellClassName(cls) + ">";

} else {

shellCreator = ", NULL";

}

QString operatorCodes = getOperatorCodes(cls).join("|");

if (operatorCodes.isEmpty()) {

operatorCodes = "0";

}

if (cls->isQObject()) {

s << "PythonQt::priv()->registerClass(&" << cls->qualifiedCppName() << "::staticMetaObject, \"" << shortPackName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module, " << operatorCodes <<");" << endl;

} else {

QString baseName = cls->baseClass()?cls->baseClass()->qualifiedCppName():"";

s << "PythonQt::priv()->registerCPPClass(\""<< cls->qualifiedCppName() << "\", \"" << baseName << "\", \"" << shortPackName <<"\", PythonQtCreateObject<PythonQtWrapper_" << cls->name() << ">" << shellCreator << ", module, " << operatorCodes <<");" << endl;

}

foreach(AbstractMetaClass* interface, cls->interfaces()) {

// the interface might be our own class... (e.g. QPaintDevice)

if (interface->qualifiedCppName() != cls->qualifiedCppName()) {

s << "PythonQt::self()->addParentClass(\""<< cls->qualifiedCppName() << "\", \"" << interface->qualifiedCppName() << "\",PythonQtUpcastingOffset<" << cls->qualifiedCppName() <<","<<interface->qualifiedCppName()<<">());" << endl;

}

}

if (cls->qualifiedCppName().contains("Ssl")) {

s << "#endif" << endl;

}

}

s << endl;

foreach (QString handler, polymorphicHandlers) {

s << "PythonQt::self()->addPolymorphicHandler(\""<< handler << "\", polymorphichandler_" << handler << ");" << endl;

}

s << endl;

QStringList list = listRegistration.toList();

list.sort();

Q_FOREACH(QString name, list) {

if (name.contains("Ssl")) {

s << "#ifndef QT_NO_SSL" << endl;

}

s << name << endl;

if (name.contains("Ssl")) {

s << "#endif" << endl;

}

}

s << "}";

s << endl;

}

}

const AbstractMetaClassList &polybase, QList<const AbstractMetaClass*>& allClasses)

{

QStringList handlers;

foreach (AbstractMetaClass *cls, polybase) {

const ComplexTypeEntry *centry = cls->typeEntry();

if (!centry->isPolymorphicBase())

continue;

bool isGraphicsItem = (cls->qualifiedCppName()=="QGraphicsItem");

bool first = true;

foreach (const AbstractMetaClass *clazz, allClasses) {

bool inherits = false;

if (isGraphicsItem) {

const AbstractMetaClass *currentClazz = clazz;

while (!inherits && currentClazz) {

foreach(AbstractMetaClass* interfaze, currentClazz->interfaces()) {

if (interfaze->qualifiedCppName()=="QGraphicsItem") {

inherits = true;

break;

}

}

currentClazz = currentClazz->baseClass();

}

} else {

inherits = clazz->inheritsFrom(cls);

}

if (clazz->package() == package && inherits) {

if (!clazz->typeEntry()->polymorphicIdValue().isEmpty()) {

// On first find, open the function

if (first) {

first = false;

QString handler = cls->name();

handlers.append(handler);

s << "static void* polymorphichandler_" << handler

<< "(const void *ptr, const char **class_name)" << endl

<< "{" << endl

<< " Q_ASSERT(ptr != 0);" << endl

<< " " << cls->qualifiedCppName() << " *object = ("

<< cls->qualifiedCppName() << " *)ptr;" << endl;

}

// For each, add case label

QString polyId = clazz->typeEntry()->polymorphicIdValue();

s << " if ("

<< polyId.replace("%1", "object")

<< ") {" << endl

<< " *class_name = \"" << clazz->name() << "\";" << endl

<< " return (" << clazz->qualifiedCppName() << "*)object;" << endl

<< " }" << endl;

} else {

QString warning = QString("class '%1' inherits from polymorphic class '%2', but has no polymorphic id set")

.arg(clazz->name())

.arg(cls->name());

ReportHandler::warning(warning);

}

}

}

// Close the function if it has been opened

if (!first) {

s << " return NULL;" << endl

<< "}" << endl;

}

}

return handlers;