tools/qdbus/tools/qdbusxml2cpp/qdbusxml2cpp.cpp File Reference

#include <QtCore/qbytearray.h>
#include <QtCore/qcoreapplication.h>
#include <QtCore/qdatetime.h>
#include <QtCore/qdebug.h>
#include <QtCore/qfile.h>
#include <QtCore/qstring.h>
#include <QtCore/qstringlist.h>
#include <QtCore/qtextstream.h>
#include <QtCore/qset.h>
#include <QtDBus>
#include "private/qdbusmetaobject_p.h"
#include "private/qdbusintrospection_p.h"
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>

Include dependency graph for qdbusxml2cpp.cpp:

Go to the source code of this file.

Defines
#define	PROGRAMNAME   "dbusxml2cpp"
#define	PROGRAMVERSION   "0.6"
#define	PROGRAMCOPYRIGHT   "Copyright (C) 2006 Trolltech ASA. All rights reserved."
#define	ANNOTATION_NO_WAIT   "org.freedesktop.DBus.Method.NoReply"
Enumerations
enum	ClassType
Functions
static void	showHelp ()
static void	showVersion ()
static QString	nextArg (QStringList &args, int i, char opt)
static void	parseCmdLine (QStringList args)
static QDBusIntrospection::Interfaces	readInput ()
static void	cleanInterfaces (QDBusIntrospection::Interfaces &interfaces)
static QString	header (const QString &name)
static QString	cpp (const QString &name)
static QString	moc (const QString &name)
static QTextStream &	writeHeader (QTextStream &ts, bool changesWillBeLost)
static QString	classNameForInterface (const QString &interface, ClassType classType)
static QByteArray	qtTypeName (const QString &signature, const QDBusIntrospection::Annotations &annotations, int paramId=-1, const char *direction="Out")
static QString	nonConstRefArg (const QByteArray &arg)
static QString	templateArg (const QByteArray &arg)
static QString	constRefArg (const QByteArray &arg)
static QStringList	makeArgNames (const QDBusIntrospection::Arguments &inputArgs, const QDBusIntrospection::Arguments &outputArgs=QDBusIntrospection::Arguments())
static void	writeArgList (QTextStream &ts, const QStringList &argNames, const QDBusIntrospection::Annotations &annotations, const QDBusIntrospection::Arguments &inputArgs, const QDBusIntrospection::Arguments &outputArgs=QDBusIntrospection::Arguments())
static QString	propertyGetter (const QDBusIntrospection::Property &property)
static QString	propertySetter (const QDBusIntrospection::Property &property)
static QString	stringify (const QString &data)
static void	openFile (const QString &fileName, QFile &file)
static void	writeProxy (const QString &filename, const QDBusIntrospection::Interfaces &interfaces)
static void	writeAdaptor (const QString &filename, const QDBusIntrospection::Interfaces &interfaces)
int	main (int argc, char **argv)
Variables
static QString	globalClassName
static QString	parentClassName
static QString	proxyFile
static QString	adaptorFile
static QString	inputFile
static bool	skipNamespaces
static bool	verbose
static bool	includeMocs
static QString	commandLine
static QStringList	includes
static QStringList	wantedInterfaces
static const char	help []
static const char	includeList []
static const char	forwardDeclarations []

---

Define Documentation

#define ANNOTATION_NO_WAIT   "org.freedesktop.DBus.Method.NoReply"

Definition at line 46 of file qdbusxml2cpp.cpp.

#define PROGRAMCOPYRIGHT   "Copyright (C) 2006 Trolltech ASA. All rights reserved."

Definition at line 44 of file qdbusxml2cpp.cpp.

#define PROGRAMNAME   "dbusxml2cpp"

Definition at line 42 of file qdbusxml2cpp.cpp.

#define PROGRAMVERSION   "0.6"

Definition at line 43 of file qdbusxml2cpp.cpp.

---

Enumeration Type Documentation

enum ClassType

Definition at line 296 of file qdbusxml2cpp.cpp.

{ Proxy, Adaptor };

---

Function Documentation

static QString classNameForInterface	(	const QString &	interface,
		ClassType	classType
	)			[static]

Definition at line 297 of file qdbusxml2cpp.cpp.

References globalClassName, QString::isEmpty(), QList< T >::last(), Proxy, QString::split(), and QString::toUpper().

Referenced by writeAdaptor(), and writeProxy().

{
    if (!globalClassName.isEmpty())
        return globalClassName;

    QStringList parts = interface.split(QLatin1Char('.'));

    QString retval;
    if (classType == Proxy)
        foreach (QString part, parts) {
            part[0] = part[0].toUpper();
            retval += part;
        }
    else {
        retval = parts.last();
        retval[0] = retval[0].toUpper();
    }

    if (classType == Proxy)
        retval += QLatin1String("Interface");
    else
        retval += QLatin1String("Adaptor");

    return retval;
}

Here is the call graph for this function:

static void cleanInterfaces

(

QDBusIntrospection::Interfaces &

interfaces

)

[static]

Definition at line 218 of file qdbusxml2cpp.cpp.

References QMap< Key, T >::begin(), QStringList::contains(), QMap< Key, T >::end(), QMap< Key, T >::erase(), QList< T >::isEmpty(), and wantedInterfaces.

Referenced by main().

{
    if (!wantedInterfaces.isEmpty()) {
        QDBusIntrospection::Interfaces::Iterator it = interfaces.begin();
        while (it != interfaces.end())
            if (!wantedInterfaces.contains(it.key()))
                it = interfaces.erase(it);
            else
                ++it;
    }
}

Here is the call graph for this function:

static QString constRefArg

(

const QByteArray &

arg

)

[static]

Definition at line 356 of file qdbusxml2cpp.cpp.

References QString::arg(), and QByteArray::startsWith().

Referenced by writeAdaptor(), writeArgList(), and writeProxy().

{
    if (!arg.startsWith('Q'))
        return QLatin1String(arg + ' ');
    else
        return QString( QLatin1String("const %1 &") ).arg( QLatin1String(arg) );
}

Here is the call graph for this function:

static QString cpp

(

const QString &

name

)

[static]

Definition at line 247 of file qdbusxml2cpp.cpp.

References QString::append(), QString::endsWith(), QString::isEmpty(), QList< T >::last(), and name.

Referenced by qt_read_xpm_image_or_array(), write_xpm_image(), writeAdaptor(), and writeProxy().

{
    QStringList parts = name.split(QLatin1Char(':'));
    QString retval = parts.last();

    if (retval.isEmpty() || retval == QLatin1String("-"))
        return retval;

    if (!retval.endsWith(QLatin1String(".h")) && !retval.endsWith(QLatin1String(".cpp")) &&
        !retval.endsWith(QLatin1String(".cc")))
        retval.append(QLatin1String(".cpp"));

    return retval;
}

Here is the call graph for this function:

static QString header

(

const QString &

name

)

[static]

Definition at line 231 of file qdbusxml2cpp.cpp.

References QString::append(), QString::endsWith(), QList< T >::first(), QString::isEmpty(), and name.

Referenced by CPP::WriteIncludes::acceptCustomWidget(), CPP::WriteIncludes::acceptUI(), CPP::WriteIncludes::add(), QTextCodec::codecForHtml(), qdesigner_internal::QDesignerResource::createCustomWidgets(), Ui3Reader::createFormDecl(), QPlastiqueStyle::drawControl(), QCleanlooksStyle::drawControl(), QCommonStyle::drawControl(), QCommonStyle::drawPrimitive(), QWindowsXPStyle::drawPrimitive(), QCleanlooksStyle::drawPrimitive(), QPdfEnginePrivate::embedFont(), QPSPrintEnginePrivate::emitHeader(), QTableModel::ensureSorted(), QCalendarModel::formatForCell(), Ui3Reader::generateUi4(), QHttp::get(), Q3Http::get(), getStyleOption(), Q3Http::head(), QHttp::head(), Q3ListViewExtraInfo::loadWidgetExtraInfo(), moc(), Q3Header::mouseDoubleClickEvent(), qdesigner_internal::PaletteEditor::on_detailsRadio_clicked(), Q3Http::operationGet(), Q3Http::operationPut(), QHttpRequestHeader::operator=(), QHttpResponseHeader::operator=(), Q3Http::post(), QHttp::post(), Uic::printDependencies(), Q3HttpHeader::Q3HttpHeader(), QHttpHeader::QHttpHeader(), QHttpRequestHeader::QHttpRequestHeader(), QHttpResponseHeader::QHttpResponseHeader(), QHttp::request(), Q3Http::request(), QTableView::resizeColumnToContents(), QTableView::resizeRowToContents(), qdesigner_internal::QDesignerResource::saveCustomWidgets(), Q3ListViewExtraInfo::saveWidgetExtraInfo(), QTableViewPrivate::sectionSpanEndLogical(), QTableViewPrivate::sectionSpanSize(), QTableView::setHorizontalHeader(), QTableModel::setItem(), QTableView::setVerticalHeader(), MainWindow::sizeHint(), QTableViewPrivate::spanContainsSection(), QCommonStyle::subElementRect(), Q3Table::updateHeaderAndResizeContents(), QDBusMetaObjectGenerator::write(), writeAdaptor(), and writeProxy().

{
    QStringList parts = name.split(QLatin1Char(':'));
    QString retval = parts.first();

    if (retval.isEmpty() || retval == QLatin1String("-"))
        return retval;

    if (!retval.endsWith(QLatin1String(".h")) && !retval.endsWith(QLatin1String(".cpp")) &&
        !retval.endsWith(QLatin1String(".cc")))
        retval.append(QLatin1String(".h"));

    return retval;
}

Here is the call graph for this function:

int main	(	int	argc,
		char **	argv
	)

Definition at line 1065 of file qdbusxml2cpp.cpp.

References adaptorFile, QCoreApplication::arguments(), cleanInterfaces(), QString::isEmpty(), parseCmdLine(), proxyFile, readInput(), writeAdaptor(), and writeProxy().

{
    QCoreApplication app(argc, argv);
    parseCmdLine(app.arguments());

    QDBusIntrospection::Interfaces interfaces = readInput();
    cleanInterfaces(interfaces);

    if (!proxyFile.isEmpty() || adaptorFile.isEmpty())
        writeProxy(proxyFile, interfaces);

    if (!adaptorFile.isEmpty())
        writeAdaptor(adaptorFile, interfaces);

    return 0;
}

Here is the call graph for this function:

static QStringList makeArgNames	(	const QDBusIntrospection::Arguments &	inputArgs,
		const QDBusIntrospection::Arguments &	outputArgs = QDBusIntrospection::Arguments()
	)			[static]

Definition at line 364 of file qdbusxml2cpp.cpp.

References QList< T >::at(), QStringList::contains(), QList< T >::count(), i, and name.

Referenced by writeAdaptor(), and writeProxy().

{
    QStringList retval;
    for (int i = 0; i < inputArgs.count(); ++i) {
        const QDBusIntrospection::Argument &arg = inputArgs.at(i);
        QString name = arg.name;
        if (name.isEmpty())
            name = QString( QLatin1String("in%1") ).arg(i);
        while (retval.contains(name))
            name += QLatin1String("_");
        retval << name;
    }
    for (int i = 0; i < outputArgs.count(); ++i) {
        const QDBusIntrospection::Argument &arg = outputArgs.at(i);
        QString name = arg.name;
        if (name.isEmpty())
            name = QString( QLatin1String("out%1") ).arg(i);
        while (retval.contains(name))
            name += QLatin1String("_");
        retval << name;
    }
    return retval;
}

Here is the call graph for this function:

static QString moc

(

const QString &

name

)

[static]

Definition at line 263 of file qdbusxml2cpp.cpp.

References header(), QString::isEmpty(), QString::length(), name, and QString::truncate().

Referenced by main(), writeAdaptor(), and writeProxy().

{
    QString retval = header(name);
    if (retval.isEmpty())
        return retval;

    retval.truncate(retval.length() - 1); // drop the h in .h
    retval += QLatin1String("moc");
    return retval;
}

Here is the call graph for this function:

static QString nextArg	(	QStringList &	args,
		int	i,
		char	opt
	)			[static]

Definition at line 111 of file qdbusxml2cpp.cpp.

References QString::isEmpty(), printf, QList< T >::takeAt(), and QList< T >::value().

Referenced by parseCmdLine().

{
    QString arg = args.value(i);
    if (arg.isEmpty()) {
        printf("-%c needs at least one argument\n", opt);
        exit(1);
    }
    return args.takeAt(i);
}

Here is the call graph for this function:

static QString nonConstRefArg

(

const QByteArray &

arg

)

[static]

Definition at line 343 of file qdbusxml2cpp.cpp.

Referenced by writeArgList().

{
    return QLatin1String(arg + " &");
}

static void openFile	(	const QString &	fileName,
		QFile &	file
	)			[static]

Definition at line 460 of file qdbusxml2cpp.cpp.

References QIODevice::errorString(), QString::isEmpty(), QFile::open(), QFile::setFileName(), QIODevice::Text, QIODevice::Truncate, and QIODevice::WriteOnly.

Referenced by writeAdaptor(), and writeProxy().

{
    if (fileName.isEmpty())
        return;

    bool isOk = false;
    if (fileName == QLatin1String("-")) {
        isOk = file.open(stdout, QIODevice::WriteOnly | QIODevice::Text);
    } else {
        file.setFileName(fileName);
        isOk = file.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text);
    }

    if (!isOk)
        fprintf(stderr, "Unable to open '%s': %s\n", qPrintable(fileName),
                qPrintable(file.errorString()));
}

Here is the call graph for this function:

static void parseCmdLine

(

QStringList

args

)

[static]

Definition at line 121 of file qdbusxml2cpp.cpp.

References adaptorFile, QList< T >::at(), QString::at(), c, commandLine, QList< T >::count(), globalClassName, i, includeMocs, includes, inputFile, QList< T >::isEmpty(), QStringList::join(), QString::length(), nextArg(), parentClassName, printf, PROGRAMNAME, proxyFile, showHelp(), showVersion(), skipNamespaces, QString::startsWith(), QList< T >::takeAt(), QList< T >::takeFirst(), QChar::toLatin1(), verbose, and wantedInterfaces.

{
    args.takeFirst();

    commandLine = QLatin1String(PROGRAMNAME " ");
    commandLine += args.join(QLatin1String(" "));

    int i = 0;
    while (i < args.count()) {

        if (!args.at(i).startsWith(QLatin1Char('-'))) {
            ++i;
            continue;
        }
        QString arg = args.takeAt(i);

        char c = '\0';
        if (arg.length() == 2)
            c = arg.at(1).toLatin1();
        else if (arg == QLatin1String("--help"))
            c = 'h';

        switch (c) {
        case 'a':
            adaptorFile = nextArg(args, i, 'a');
            break;

        case 'c':
            globalClassName = nextArg(args, i, 'c');
            break;

        case 'v':
            verbose = true;
            break;

        case 'i':
            includes << nextArg(args, i, 'i');
            break;

        case 'l':
            parentClassName = nextArg(args, i, 'l');
            break;

        case 'm':
            includeMocs = true;
            break;

        case 'N':
            skipNamespaces = true;
            break;

        case '?':
        case 'h':
            showHelp();
            break;

        case 'V':
            showVersion();
            break;

        case 'p':
            proxyFile = nextArg(args, i, 'p');
            break;

        default:
            printf("unknown option: '%s'\n", qPrintable(arg));
            exit(1);
        }
    }

    if (!args.isEmpty())
        inputFile = args.takeFirst();

    wantedInterfaces << args;
}

Here is the call graph for this function:

static QString propertyGetter

(

const QDBusIntrospection::Property &

property

)

[static]

Definition at line 424 of file qdbusxml2cpp.cpp.

References QDBusIntrospection::Property::annotations, QString::isEmpty(), QDBusIntrospection::Property::name, and QString::toLower().

Referenced by writeAdaptor(), and writeProxy().

{
    QString getter = property.annotations.value(QLatin1String("com.trolltech.QtDBus.propertyGetter"));
    if (getter.isEmpty()) {
        getter =  property.name;
        getter[0] = getter[0].toLower();
    }
    return getter;
}

Here is the call graph for this function:

static QString propertySetter

(

const QDBusIntrospection::Property &

property

)

[static]

Definition at line 434 of file qdbusxml2cpp.cpp.

References QDBusIntrospection::Property::annotations, QString::isEmpty(), QDBusIntrospection::Property::name, and QString::toUpper().

Referenced by writeAdaptor(), and writeProxy().

{
    QString setter = property.annotations.value(QLatin1String("com.trolltech.QtDBus.propertySetter"));
    if (setter.isEmpty()) {
        setter = QLatin1String("set") + property.name;
        setter[3] = setter[3].toUpper();
    }
    return setter;
}

Here is the call graph for this function:

static QByteArray qtTypeName	(	const QString &	signature,
		const QDBusIntrospection::Annotations &	annotations,
		int	paramId = -1,
		const char *	direction = "Out"
	)			[static]

Definition at line 323 of file qdbusxml2cpp.cpp.

References QString::arg(), direction, QString::fromLatin1(), QVariant::Invalid, QString::isEmpty(), QDBusMetaType::signatureToType(), QString::toLatin1(), type, QVariant::typeToName(), and QMap< Key, T >::value().

Referenced by writeAdaptor(), writeArgList(), and writeProxy().

{
    int type = QDBusMetaType::signatureToType(signature.toLatin1());
    if (type == QVariant::Invalid) {
        QString annotationName = QString::fromLatin1("com.trolltech.QtDBus.QtTypeName");
        if (paramId >= 0)
            annotationName += QString::fromLatin1(".%1%2").arg(direction).arg(paramId);
        QString qttype = annotations.value(annotationName);
        if (!qttype.isEmpty())
            return qttype.toLatin1();

        fprintf(stderr, "Got unknown type `%s'\n", qPrintable(signature));
        fprintf(stderr, "You should add <annotation name=\"%s\" value=\"<type>\"/> to the XML description\n",
                qPrintable(annotationName));
        exit(1);
    }

    return QVariant::typeToName(QVariant::Type(type));
}

Here is the call graph for this function:

static QDBusIntrospection::Interfaces readInput

(

)

[static]

Definition at line 197 of file qdbusxml2cpp.cpp.

References data, QString::fromUtf8(), inputFile, QString::isEmpty(), QFile::open(), QDBusIntrospection::parseInterfaces(), QIODevice::readAll(), and QIODevice::ReadOnly.

Referenced by main().

{
    QFile input(inputFile);
    if (inputFile.isEmpty() || inputFile == QLatin1String("-"))
        input.open(stdin, QIODevice::ReadOnly);
    else
        input.open(QIODevice::ReadOnly);

    QByteArray data = input.readAll();

    // check if the input is already XML
    data = data.trimmed();
    if (data.startsWith("<!DOCTYPE ") || data.startsWith("<?xml") ||
        data.startsWith("<node") || data.startsWith("<interface"))
        // already XML
        return QDBusIntrospection::parseInterfaces(QString::fromUtf8(data));

    fprintf(stderr, "Cannot process input. Stop.\n");
    exit(1);
}

Here is the call graph for this function:

static void showHelp

(

)

[static]

Definition at line 98 of file qdbusxml2cpp.cpp.

References help, and printf.

{
    printf("%s", help);
    exit(0);
}

static void showVersion

(

)

[static]

Definition at line 104 of file qdbusxml2cpp.cpp.

References printf, PROGRAMNAME, and PROGRAMVERSION.

{
    printf("%s version %s\n", PROGRAMNAME, PROGRAMVERSION);
    printf("D-Bus binding tool for Qt\n");
    exit(0);
}

static QString stringify

(

const QString &

data

)

[static]

Definition at line 444 of file qdbusxml2cpp.cpp.

References data, and i.

Referenced by writeAdaptor().

{
    QString retval;
    int i;
    for (i = 0; i < data.length(); ++i) {
        retval += QLatin1Char('\"');
        for ( ; i < data.length() && data[i] != QLatin1Char('\n'); ++i)
            if (data[i] == QLatin1Char('\"'))
                retval += QLatin1String("\\\"");
            else
                retval += data[i];
        retval += QLatin1String("\\n\"\n");
    }
    return retval;
}

static QString templateArg

(

const QByteArray &

arg

)

[static]

Definition at line 348 of file qdbusxml2cpp.cpp.

References QByteArray::endsWith().

Referenced by writeProxy().

{
    if (!arg.endsWith('>'))
        return QLatin1String(arg);

    return QLatin1String(arg + ' ');
}

Here is the call graph for this function:

static void writeAdaptor	(	const QString &	filename,
		const QDBusIntrospection::Interfaces &	interfaces
	)			[static]

Definition at line 764 of file qdbusxml2cpp.cpp.

References QDBusIntrospection::Property::access, Adaptor, ANNOTATION_NO_WAIT, QDBusIntrospection::Property::annotations, QDBusIntrospection::Signal::annotations, QString::arg(), QList< T >::at(), classNameForInterface(), constRefArg(), cpp(), QDateTime::currentDateTime(), QTextStream::endl(), QTextStream::flush(), forwardDeclarations, header(), i, include(), includeList, includeMocs, includes, QDBusIntrospection::Interface::introspection, QByteArray::isEmpty(), QString::isEmpty(), QString::lastIndexOf(), makeArgNames(), method, QDBusIntrospection::Interface::methods, QString::mid(), moc(), name, QDBusIntrospection::Signal::name, QDBusIntrospection::Property::name, QDBusIntrospection::Interface::name, openFile(), QDBusIntrospection::Signal::outputArgs, parentClassName, QDBusIntrospection::Interface::properties, propertyGetter(), propertySetter(), qtTypeName(), QDBusIntrospection::Property::Read, QString::replace(), QDBusIntrospection::Interface::signals_, stringify(), toTime_t(), QString::toUpper(), type, QDBusIntrospection::Property::type, QDBusIntrospection::Property::Write, QIODevice::write(), writeArgList(), and writeHeader().

Referenced by main().

{
    // open the file
    QString headerName = header(filename);
    QByteArray headerData;
    QTextStream hs(&headerData);

    QString cppName = cpp(filename);
    QByteArray cppData;
    QTextStream cs(&cppData);

    // write the headers
    writeHeader(hs, false);
    if (cppName != headerName)
        writeHeader(cs, true);

    // include guards:
    QString includeGuard;
    if (!headerName.isEmpty() && headerName != QLatin1String("-")) {
        includeGuard = headerName.toUpper().replace(QLatin1Char('.'), QLatin1Char('_'));
        int pos = includeGuard.lastIndexOf(QLatin1Char('/'));
        if (pos != -1)
            includeGuard = includeGuard.mid(pos + 1);
    } else {
        includeGuard = QLatin1String("QDBUSXML2CPP_ADAPTOR");
    }
    includeGuard = QString(QLatin1String("%1_%2"))
                   .arg(includeGuard)
                   .arg(QDateTime::currentDateTime().toTime_t());
    hs << "#ifndef " << includeGuard << endl
       << "#define " << includeGuard << endl
       << endl;

    // include our stuff:
    hs << "#include <QtCore/QObject>" << endl;
    if (cppName == headerName)
        hs << "#include <QtCore/QMetaObject>" << endl
           << "#include <QtCore/QVariant>" << endl;
    hs << "#include <QtDBus/QtDBus>" << endl;

    foreach (QString include, includes) {
        hs << "#include \"" << include << "\"" << endl;
        if (headerName.isEmpty())
            cs << "#include \"" << include << "\"" << endl;
    }

    if (cppName != headerName) {
        if (!headerName.isEmpty() && headerName != QLatin1String("-"))
            cs << "#include \"" << headerName << "\"" << endl;

        cs << "#include <QtCore/QMetaObject>" << endl
           << includeList
           << endl;
        hs << forwardDeclarations;
    } else {
        hs << includeList;
    }

    hs << endl;

    QString parent = parentClassName;
    if (parentClassName.isEmpty())
        parent = QLatin1String("QObject");

    foreach (const QDBusIntrospection::Interface *interface, interfaces) {
        QString className = classNameForInterface(interface->name, Adaptor);

        // comment:
        hs << "/*" << endl
           << " * Adaptor class for interface " << interface->name << endl
           << " */" << endl;
        cs << "/*" << endl
           << " * Implementation of adaptor class " << className << endl
           << " */" << endl
           << endl;

        // class header:
        hs << "class " << className << ": public QDBusAbstractAdaptor" << endl
           << "{" << endl
           << "    Q_OBJECT" << endl
           << "    Q_CLASSINFO(\"D-Bus Interface\", \"" << interface->name << "\")" << endl
           << "    Q_CLASSINFO(\"D-Bus Introspection\", \"\"" << endl
           << stringify(interface->introspection)
           << "        \"\")" << endl
           << "public:" << endl
           << "    " << className << "(" << parent << " *parent);" << endl
           << "    virtual ~" << className << "();" << endl
           << endl;

        if (!parentClassName.isEmpty())
            hs << "    inline " << parent << " *parent() const" << endl
               << "    { return static_cast<" << parent << " *>(QObject::parent()); }" << endl
               << endl;

        // constructor/destructor
        cs << className << "::" << className << "(" << parent << " *parent)" << endl
           << "    : QDBusAbstractAdaptor(parent)" << endl
           << "{" << endl
           << "    // constructor" << endl
           << "    setAutoRelaySignals(true);" << endl
           << "}" << endl
           << endl
           << className << "::~" << className << "()" << endl
           << "{" << endl
           << "    // destructor" << endl
           << "}" << endl
           << endl;

        hs << "public: // PROPERTIES" << endl;
        foreach (const QDBusIntrospection::Property &property, interface->properties) {
            QByteArray type = qtTypeName(property.type, property.annotations);
            QString constRefType = constRefArg(type);
            QString getter = propertyGetter(property);
            QString setter = propertySetter(property);

            hs << "    Q_PROPERTY(" << type << " " << property.name;
            if (property.access != QDBusIntrospection::Property::Write)
                hs << " READ " << getter;
            if (property.access != QDBusIntrospection::Property::Read)
                hs << " WRITE " << setter;
            hs << ")" << endl;

            // getter:
            if (property.access != QDBusIntrospection::Property::Write) {
                hs << "    " << type << " " << getter << "() const;" << endl;
                cs << type << " "
                   << className << "::" << getter << "() const" << endl
                   << "{" << endl
                   << "    // get the value of property " << property.name << endl
                   << "    return qvariant_cast< " << type <<" >(parent()->property(\"" << property.name << "\"));" << endl
                   << "}" << endl
                   << endl;
            }

            // setter
            if (property.access != QDBusIntrospection::Property::Read) {
                hs << "    void " << setter << "(" << constRefType << "value);" << endl;
                cs << "void " << className << "::" << setter << "(" << constRefType << "value)" << endl
                   << "{" << endl
                   << "    // set the value of property " << property.name << endl
                   << "    parent()->setProperty(\"" << property.name << "\", value);" << endl
                   << "}" << endl
                   << endl;
            }

            hs << endl;
        }

        hs << "public Q_SLOTS: // METHODS" << endl;
        foreach (const QDBusIntrospection::Method &method, interface->methods) {
            bool isNoReply =
                method.annotations.value(QLatin1String(ANNOTATION_NO_WAIT)) == QLatin1String("true");
            if (isNoReply && !method.outputArgs.isEmpty()) {
                fprintf(stderr, "warning: method %s in interface %s is marked 'no-reply' but has output arguments.\n",
                        qPrintable(method.name), qPrintable(interface->name));
                continue;
            }

            hs << "    ";
            if (method.annotations.value(QLatin1String("org.freedesktop.DBus.Deprecated")) ==
                QLatin1String("true"))
                hs << "Q_DECL_DEPRECATED ";

            QByteArray returnType;
            if (isNoReply) {
                hs << "Q_NOREPLY void ";
                cs << "void ";
            } else if (method.outputArgs.isEmpty()) {
                hs << "void ";
                cs << "void ";
            } else {
                returnType = qtTypeName(method.outputArgs.first().type, method.annotations, 0, "Out");
                hs << returnType << " ";
                cs << returnType << " ";
            }

            QString name = method.name;
            hs << name << "(";
            cs << className << "::" << name << "(";

            QStringList argNames = makeArgNames(method.inputArgs, method.outputArgs);
            writeArgList(hs, argNames, method.annotations, method.inputArgs, method.outputArgs);
            writeArgList(cs, argNames, method.annotations, method.inputArgs, method.outputArgs);

            hs << ");" << endl; // finished for header
            cs << ")" << endl
               << "{" << endl
               << "    // handle method call " << interface->name << "." << method.name << endl;

            // make the call
            bool usingInvokeMethod = false;
            if (parentClassName.isEmpty() && method.inputArgs.count() <= 10
                && method.outputArgs.count() <= 1)
                usingInvokeMethod = true;

            if (usingInvokeMethod) {
                // we are using QMetaObject::invokeMethod
                if (!returnType.isEmpty())
                    cs << "    " << returnType << " " << argNames.at(method.inputArgs.count())
                       << ";" << endl;

                static const char invoke[] = "    QMetaObject::invokeMethod(parent(), \"";
                cs << invoke << name << "\"";

                if (!method.outputArgs.isEmpty())
                    cs << ", Q_RETURN_ARG("
                       << qtTypeName(method.outputArgs.at(0).type, method.annotations,
                                     0, "Out")
                       << ", "
                       << argNames.at(method.inputArgs.count())
                       << ")";

                for (int i = 0; i < method.inputArgs.count(); ++i)
                    cs << ", Q_ARG("
                       << qtTypeName(method.inputArgs.at(i).type, method.annotations,
                                     i, "In")
                       << ", "
                       << argNames.at(i)
                       << ")";

                cs << ");" << endl;

                if (!returnType.isEmpty())
                    cs << "    return " << argNames.at(method.inputArgs.count()) << ";" << endl;
            } else {
                if (parentClassName.isEmpty())
                    cs << "    //";
                else
                    cs << "    ";

                if (!method.outputArgs.isEmpty())
                    cs << "return ";

                if (parentClassName.isEmpty())
                    cs << "static_cast<YourObjectType *>(parent())->";
                else
                    cs << "parent()->";
                cs << name << "(";

                int argPos = 0;
                bool first = true;
                for (int i = 0; i < method.inputArgs.count(); ++i) {
                    cs << (first ? "" : ", ") << argNames.at(argPos++);
                    first = false;
                }
                ++argPos;           // skip retval, if any
                for (int i = 1; i < method.outputArgs.count(); ++i) {
                    cs << (first ? "" : ", ") << argNames.at(argPos++);
                    first = false;
                }

                cs << ");" << endl;
            }
            cs << "}" << endl
               << endl;
        }

        hs << "Q_SIGNALS: // SIGNALS" << endl;
        foreach (const QDBusIntrospection::Signal &signal, interface->signals_) {
            hs << "    ";
            if (signal.annotations.value(QLatin1String("org.freedesktop.DBus.Deprecated")) ==
                QLatin1String("true"))
                hs << "Q_DECL_DEPRECATED ";

            hs << "void " << signal.name << "(";

            QStringList argNames = makeArgNames(signal.outputArgs);
            writeArgList(hs, argNames, signal.annotations, signal.outputArgs);

            hs << ");" << endl; // finished for header
        }

        // close the class:
        hs << "};" << endl
           << endl;
    }

    // close the include guard
    hs << "#endif" << endl;

    QString mocName = moc(filename);
    if (includeMocs && !mocName.isEmpty())
        cs << endl
           << "#include \"" << mocName << "\"" << endl;

    cs.flush();
    hs.flush();

    QFile file;
    openFile(headerName, file);
    file.write(headerData);

    if (headerName == cppName) {
        file.write(cppData);
    } else {
        QFile cppFile;
        openFile(cppName, cppFile);
        cppFile.write(cppData);
    }
}

Here is the call graph for this function:

static void writeArgList	(	QTextStream &	ts,
		const QStringList &	argNames,
		const QDBusIntrospection::Annotations &	annotations,
		const QDBusIntrospection::Arguments &	inputArgs,
		const QDBusIntrospection::Arguments &	outputArgs = QDBusIntrospection::Arguments()
	)			[static]

Definition at line 390 of file qdbusxml2cpp.cpp.

References QList< T >::at(), QString::at(), constRefArg(), QList< T >::count(), i, name, nonConstRefArg(), qtTypeName(), and type.

Referenced by writeAdaptor(), and writeProxy().

{
    // input args:
    bool first = true;
    int argPos = 0;
    for (int i = 0; i < inputArgs.count(); ++i) {
        const QDBusIntrospection::Argument &arg = inputArgs.at(i);
        QString type = constRefArg(qtTypeName(arg.type, annotations, i, "In"));

        if (!first)
            ts << ", ";
        ts << type << argNames.at(argPos++);
        first = false;
    }

    argPos++;

    // output args
    // yes, starting from 1
    for (int i = 1; i < outputArgs.count(); ++i) {
        const QDBusIntrospection::Argument &arg = outputArgs.at(i);
        QString name = arg.name;

        if (!first)
            ts << ", ";
        ts << nonConstRefArg(qtTypeName(arg.type, annotations, i, "Out"))
           << argNames.at(argPos++);
        first = false;
    }
}

Here is the call graph for this function:

static QTextStream& writeHeader	(	QTextStream &	ts,
		bool	changesWillBeLost
	)			[static]

Definition at line 274 of file qdbusxml2cpp.cpp.

References commandLine, QTextStream::endl(), PROGRAMCOPYRIGHT, PROGRAMNAME, and PROGRAMVERSION.

Referenced by writeAdaptor(), and writeProxy().

{
    ts << "/*" << endl
       << " * This file was generated by " PROGRAMNAME " version " PROGRAMVERSION << endl
       << " * Command line was: " << commandLine << endl
       << " *" << endl
       << " * " PROGRAMNAME " is " PROGRAMCOPYRIGHT << endl
       << " *" << endl
       << " * This is an auto-generated file." << endl;

    if (changesWillBeLost)
        ts << " * Do not edit! All changes made to it will be lost." << endl;
    else
        ts << " * This file may have been hand-edited. Look for HAND-EDIT comments" << endl
           << " * before re-generating it." << endl;

    ts << " */" << endl
       << endl;

    return ts;
}

Here is the call graph for this function:

static void writeProxy	(	const QString &	filename,
		const QDBusIntrospection::Interfaces &	interfaces
	)			[static]

Definition at line 478 of file qdbusxml2cpp.cpp.

References QDBusIntrospection::Property::access, ANNOTATION_NO_WAIT, QDBusIntrospection::Property::annotations, QDBusIntrospection::Signal::annotations, QString::arg(), QList< T >::at(), classNameForInterface(), QMap< Key, T >::constBegin(), QMap< Key, T >::constEnd(), constRefArg(), QList< T >::count(), cpp(), QDateTime::currentDateTime(), QTextStream::endl(), QTextStream::flush(), header(), i, include(), includeList, includeMocs, includes, QString::isEmpty(), j, QString::lastIndexOf(), makeArgNames(), method, QString::mid(), moc(), name, QDBusIntrospection::Signal::name, QDBusIntrospection::Property::name, openFile(), QDBusIntrospection::Signal::outputArgs, propertyGetter(), propertySetter(), Proxy, qtTypeName(), QDBusIntrospection::Property::Read, QString::replace(), skipNamespaces, QList< T >::takeLast(), templateArg(), toTime_t(), QString::toUpper(), type, QDBusIntrospection::Property::type, QDBusIntrospection::Property::Write, QIODevice::write(), writeArgList(), and writeHeader().

Referenced by main().

{
    // open the file
    QString headerName = header(filename);
    QByteArray headerData;
    QTextStream hs(&headerData);

    QString cppName = cpp(filename);
    QByteArray cppData;
    QTextStream cs(&cppData);

    // write the header:
    writeHeader(hs, true);
    if (cppName != headerName)
        writeHeader(cs, false);

    // include guards:
    QString includeGuard;
    if (!headerName.isEmpty() && headerName != QLatin1String("-")) {
        includeGuard = headerName.toUpper().replace(QLatin1Char('.'), QLatin1Char('_'));
        int pos = includeGuard.lastIndexOf(QLatin1Char('/'));
        if (pos != -1)
            includeGuard = includeGuard.mid(pos + 1);
    } else {
        includeGuard = QLatin1String("QDBUSXML2CPP_PROXY");
    }
    includeGuard = QString(QLatin1String("%1_%2"))
                   .arg(includeGuard)
                   .arg(QDateTime::currentDateTime().toTime_t());
    hs << "#ifndef " << includeGuard << endl
       << "#define " << includeGuard << endl
       << endl;

    // include our stuff:
    hs << "#include <QtCore/QObject>" << endl
       << includeList
       << "#include <QtDBus/QtDBus>" << endl;

    foreach (QString include, includes) {
        hs << "#include \"" << include << "\"" << endl;
        if (headerName.isEmpty())
            cs << "#include \"" << include << "\"" << endl;
    }

    hs << endl;

    if (cppName != headerName) {
        if (!headerName.isEmpty() && headerName != QLatin1String("-"))
            cs << "#include \"" << headerName << "\"" << endl << endl;
    }

    foreach (const QDBusIntrospection::Interface *interface, interfaces) {
        QString className = classNameForInterface(interface->name, Proxy);

        // comment:
        hs << "/*" << endl
           << " * Proxy class for interface " << interface->name << endl
           << " */" << endl;
        cs << "/*" << endl
           << " * Implementation of interface class " << className << endl
           << " */" << endl
           << endl;

        // class header:
        hs << "class " << className << ": public QDBusAbstractInterface" << endl
           << "{" << endl
           << "    Q_OBJECT" << endl;

        // the interface name
        hs << "public:" << endl
           << "    static inline const char *staticInterfaceName()" << endl
           << "    { return \"" << interface->name << "\"; }" << endl
           << endl;

        // constructors/destructors:
        hs << "public:" << endl
           << "    " << className << "(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = 0);" << endl
           << endl
           << "    ~" << className << "();" << endl
           << endl;
        cs << className << "::" << className << "(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent)" << endl
           << "    : QDBusAbstractInterface(service, path, staticInterfaceName(), connection, parent)" << endl
           << "{" << endl
           << "}" << endl
           << endl
           << className << "::~" << className << "()" << endl
           << "{" << endl
           << "}" << endl
           << endl;

        // properties:
        foreach (const QDBusIntrospection::Property &property, interface->properties) {
            QByteArray type = qtTypeName(property.type, property.annotations);
            QString templateType = templateArg(type);
            QString constRefType = constRefArg(type);
            QString getter = propertyGetter(property);
            QString setter = propertySetter(property);

            hs << "    Q_PROPERTY(" << type << " " << property.name;

            // getter:
            if (property.access != QDBusIntrospection::Property::Write)
                // it's readble
                hs << " READ " << getter;

            // setter
            if (property.access != QDBusIntrospection::Property::Read)
                // it's writeable
                hs << " WRITE " << setter;

            hs << ")" << endl;

            // getter:
            if (property.access != QDBusIntrospection::Property::Write) {
                hs << "    inline " << type << " " << getter << "() const" << endl;
                if (type != "QVariant")
                    hs << "    { return qvariant_cast< " << type << " >(internalPropGet(\""
                       << property.name << "\")); }" << endl;
                else
                    hs << "    { return internalPropGet(\"" << property.name << "\"); }" << endl;
            }

            // setter:
            if (property.access != QDBusIntrospection::Property::Read) {
                hs << "    inline void " << setter << "(" << constRefArg(type) << "value)" << endl
                   << "    { internalPropSet(\"" << property.name
                   << "\", qVariantFromValue(value)); }" << endl;
            }

            hs << endl;
        }

        // methods:
        hs << "public Q_SLOTS: // METHODS" << endl;
        foreach (const QDBusIntrospection::Method &method, interface->methods) {
            bool isNoReply =
                method.annotations.value(QLatin1String(ANNOTATION_NO_WAIT)) == QLatin1String("true");
            if (isNoReply && !method.outputArgs.isEmpty()) {
                fprintf(stderr, "warning: method %s in interface %s is marked 'no-reply' but has output arguments.\n",
                        qPrintable(method.name), qPrintable(interface->name));
                continue;
            }

            hs << "    inline ";

            if (method.annotations.value(QLatin1String("org.freedesktop.DBus.Deprecated")) == QLatin1String("true"))
                hs << "Q_DECL_DEPRECATED ";

            if (isNoReply)
                hs << "Q_NOREPLY void ";
            else if (method.outputArgs.isEmpty())
                hs << "QDBusReply<void> ";
            else {
                hs << "QDBusReply<"
                   << templateArg(qtTypeName(method.outputArgs.first().type, method.annotations, 0, "Out")) << "> ";
            }

            hs << method.name << "(";

            QStringList argNames = makeArgNames(method.inputArgs, method.outputArgs);
            writeArgList(hs, argNames, method.annotations, method.inputArgs, method.outputArgs);

            hs << ")" << endl
               << "    {" << endl
               << "        QList<QVariant> argumentList;" << endl;

            int argPos = 0;
            if (!method.inputArgs.isEmpty()) {
                hs << "        argumentList";
                for (argPos = 0; argPos < method.inputArgs.count(); ++argPos)
                    hs << " << qVariantFromValue(" << argNames.at(argPos) << ')';
                hs << ";" << endl;
            }

            if (method.outputArgs.count() > 1)
                hs << "        QDBusMessage reply = callWithArgumentList(QDBus::Block, "
                   <<  "QLatin1String(\"" << method.name << "\"), argumentList);" << endl;
            else if (!isNoReply)
                hs << "        return callWithArgumentList(QDBus::Block, "
                   <<  "QLatin1String(\"" << method.name << "\"), argumentList);" << endl;
            else
                hs << "        callWithArgumentList(QDBus::NoBlock, "
                   <<  "QLatin1String(\"" << method.name << "\"), argumentList);" << endl;

            argPos++;
            if (method.outputArgs.count() > 1) {
                hs << "        if (reply.type() == QDBusMessage::ReplyMessage && reply.arguments().count() == "
                   << method.outputArgs.count() << ") {" << endl;

                // yes, starting from 1
                for (int i = 1; i < method.outputArgs.count(); ++i)
                    hs << "            " << argNames.at(argPos++) << " = qdbus_cast<"
                       << templateArg(qtTypeName(method.outputArgs.at(i).type, method.annotations, i, "Out"))
                       << ">(reply.arguments().at(" << i << "));" << endl;
                hs << "        }" << endl
                   << "        return reply;" << endl;
            }

            // close the function:
            hs << "    }" << endl
               << endl;
        }

        hs << "Q_SIGNALS: // SIGNALS" << endl;
        foreach (const QDBusIntrospection::Signal &signal, interface->signals_) {
            hs << "    ";
            if (signal.annotations.value(QLatin1String("org.freedesktop.DBus.Deprecated")) ==
                QLatin1String("true"))
                hs << "Q_DECL_DEPRECATED ";

            hs << "void " << signal.name << "(";

            QStringList argNames = makeArgNames(signal.outputArgs);
            writeArgList(hs, argNames, signal.annotations, signal.outputArgs);

            hs << ");" << endl; // finished for header
        }

        // close the class:
        hs << "};" << endl
           << endl;
    }

    if (!skipNamespaces) {
        QStringList last;
        QDBusIntrospection::Interfaces::ConstIterator it = interfaces.constBegin();
        do
        {
            QStringList current;
            QString name;
            if (it != interfaces.constEnd()) {
                current = it->constData()->name.split(QLatin1Char('.'));
                name = current.takeLast();
            }

            int i = 0;
            while (i < current.count() && i < last.count() && current.at(i) == last.at(i))
                ++i;

            // i parts matched
            // close last.arguments().count() - i namespaces:
            for (int j = i; j < last.count(); ++j)
                hs << QString((last.count() - j - 1 + i) * 2, QLatin1Char(' ')) << "}" << endl;

            // open current.arguments().count() - i namespaces
            for (int j = i; j < current.count(); ++j)
                hs << QString(j * 2, QLatin1Char(' ')) << "namespace " << current.at(j) << " {" << endl;

            // add this class:
            if (!name.isEmpty()) {
                hs << QString(current.count() * 2, QLatin1Char(' '))
                   << "typedef ::" << classNameForInterface(it->constData()->name, Proxy)
                   << " " << name << ";" << endl;
            }

            if (it == interfaces.constEnd())
                break;
            ++it;
            last = current;
        } while (true);
    }

    // close the include guard
    hs << "#endif" << endl;

    QString mocName = moc(filename);
    if (includeMocs && !mocName.isEmpty())
        cs << endl
           << "#include \"" << mocName << "\"" << endl;

    cs.flush();
    hs.flush();

    QFile file;
    openFile(headerName, file);
    file.write(headerData);

    if (headerName == cppName) {
        file.write(cppData);
    } else {
        QFile cppFile;
        openFile(cppName, cppFile);
        cppFile.write(cppData);
    }
}

Here is the call graph for this function:

---

Variable Documentation

QString adaptorFile [static]

Definition at line 51 of file qdbusxml2cpp.cpp.

Referenced by main(), and parseCmdLine().

QString commandLine [static]

Definition at line 56 of file qdbusxml2cpp.cpp.

Referenced by parseCmdLine(), and writeHeader().

const char forwardDeclarations[] [static]

Initial value:

    "class QByteArray;\n"
    "template<class T> class QList;\n"
    "template<class Key, class Value> class QMap;\n"
    "class QString;\n"
    "class QStringList;\n"
    "class QVariant;\n"

Definition at line 90 of file qdbusxml2cpp.cpp.

Referenced by writeAdaptor().

QString globalClassName [static]

Definition at line 48 of file qdbusxml2cpp.cpp.

Referenced by classNameForInterface(), and parseCmdLine().

const char help[] [static]

Initial value:

    "Usage: " PROGRAMNAME " [options...] [xml-or-xml-file] [interfaces...]\n"
    "Produces the C++ code to implement the interfaces defined in the input file.\n"
    "If no options are given, the code is written to the standard output.\n"
    "\n"
    "Options:\n"
    "  -a <filename>    Write the adaptor code to <filename>\n"
    "  -c <classname>   Use <classname> as the class name for the generated classes\n"
    "  -h               Show this information\n"
    "  -i <filename>    Add #include to the output\n"
    "  -l <classname>   When generating an adaptor, use <classname> as the parent class\n"
    "  -m               Generate #include \"filename.moc\" statements in the .cpp files\n"
    "  -N               Don't use namespaces\n"
    "  -p <filename>    Write the proxy code to <filename>\n"
    "  -v               Be verbose.\n"
    "  -V               Show the program version and quit.\n"
    "\n"
    "If the file name given to the options -a and -p does not end in .cpp or .h, the\n"
    "program will automatically append the suffixes and produce both files.\n"
    "You can also use a colon (:) to separate the header name from the source file\n"
    "name, as in '-a filename_p.h:filename.cpp'.\n"

Definition at line 60 of file qdbusxml2cpp.cpp.

const char includeList[] [static]

Initial value:

    "#include <QtCore/QByteArray>\n"
    "#include <QtCore/QList>\n"
    "#include <QtCore/QMap>\n"
    "#include <QtCore/QString>\n"
    "#include <QtCore/QStringList>\n"
    "#include <QtCore/QVariant>\n"

Definition at line 82 of file qdbusxml2cpp.cpp.

Referenced by writeAdaptor(), and writeProxy().

bool includeMocs [static]

Definition at line 55 of file qdbusxml2cpp.cpp.

Referenced by parseCmdLine(), writeAdaptor(), and writeProxy().

QStringList includes [static]

Definition at line 57 of file qdbusxml2cpp.cpp.

Referenced by TreeWalker::acceptIncludes(), qdesigner_internal::QDesignerResource::create(), Ui3Reader::generateUi4(), parseCmdLine(), Uic::printDependencies(), qdesigner_internal::QDesignerResource::saveDom(), writeAdaptor(), and writeProxy().

QString inputFile [static]

Definition at line 52 of file qdbusxml2cpp.cpp.

Referenced by main(), parseCmdLine(), and readInput().

QString parentClassName [static]

Definition at line 49 of file qdbusxml2cpp.cpp.

Referenced by parseCmdLine(), and writeAdaptor().

QString proxyFile [static]

Definition at line 50 of file qdbusxml2cpp.cpp.

Referenced by main(), and parseCmdLine().

bool skipNamespaces [static]

Definition at line 53 of file qdbusxml2cpp.cpp.

Referenced by parseCmdLine(), and writeProxy().

bool verbose [static]

Definition at line 54 of file qdbusxml2cpp.cpp.

QStringList wantedInterfaces [static]

Definition at line 58 of file qdbusxml2cpp.cpp.

Referenced by cleanInterfaces(), and parseCmdLine().

---