Initial import of kinetic-dui branch from the old kinetic

28 files changed, 2194 insertions, 421 deletions

diff --git a/tools/configure/configureapp.cpp b/tools/configure/configureapp.cpp
index bcbf557..9930da8 100644
--- a/tools/configure/configureapp.cpp
+++ b/tools/configure/configureapp.cpp
@@ -254,6 +254,7 @@ Configure::Configure( int& argc, char** argv )
     dictionary[ "PHONON_BACKEND" ]  = "yes";
     dictionary[ "DIRECTSHOW" ]      = "no";
     dictionary[ "WEBKIT" ]          = "auto";
+    dictionary[ "DECLARATIVE" ]     = "yes";
     dictionary[ "PLUGIN_MANIFESTS" ] = "yes";
 
     QString version;
@@ -859,6 +860,10 @@ void Configure::parseCmdLine()
             dictionary[ "WEBKIT" ] = "no";
         } else if( configCmdLine.at(i) == "-webkit" ) {
             dictionary[ "WEBKIT" ] = "yes";
+        } else if( configCmdLine.at(i) == "-no-declarative" ) {
+            dictionary[ "DECLARATIVE" ] = "no";
+        } else if( configCmdLine.at(i) == "-declarative" ) {
+            dictionary[ "DECLARATIVE" ] = "yes";
         } else if( configCmdLine.at(i) == "-no-plugin-manifests" ) {
             dictionary[ "PLUGIN_MANIFESTS" ] = "no";
         } else if( configCmdLine.at(i) == "-plugin-manifests" ) {
@@ -1593,6 +1598,8 @@ bool Configure::displayHelp()
         desc("WEBKIT", "yes",   "-webkit",              "Compile in the WebKit module (WebKit is built if a decent C++ compiler is used.)");
         desc("SCRIPTTOOLS", "no", "-no-scripttools",    "Do not build the QtScriptTools module.");
         desc("SCRIPTTOOLS", "yes", "-scripttools",      "Build the QtScriptTools module.");
+        desc("DECLARATIVE", "no",    "-no-declarative", "Do not build the declarative module");
+        desc("DECLARATIVE", "yes",   "-declarative",    "Build the declarative module");
 
         desc(                   "-arch <arch>",         "Specify an architecture.\n"
                                                         "Available values for <arch>:");
@@ -2320,6 +2327,9 @@ void Configure::generateOutputVars()
     if (dictionary["WEBKIT"] == "yes")
         qtConfig += "webkit";
 
+    if (dictionary["DECLARATIVE"] == "yes")
+        qtConfig += "declarative";
+
     // We currently have no switch for QtSvg, so add it unconditionally.
     qtConfig += "svg";
 
@@ -2672,6 +2682,7 @@ void Configure::generateConfigfiles()
         if(dictionary["DBUS"] == "no")              qconfigList += "QT_NO_DBUS";
         if(dictionary["IPV6"] == "no")              qconfigList += "QT_NO_IPV6";
         if(dictionary["WEBKIT"] == "no")            qconfigList += "QT_NO_WEBKIT";
+        if(dictionary["DECLARATIVE"] == "no")       qconfigList += "QT_NO_DECLARATIVE";
         if(dictionary["PHONON"] == "no")            qconfigList += "QT_NO_PHONON";
         if(dictionary["XMLPATTERNS"] == "no")       qconfigList += "QT_NO_XMLPATTERNS";
         if(dictionary["SCRIPTTOOLS"] == "no")       qconfigList += "QT_NO_SCRIPTTOOLS";
@@ -2932,6 +2943,7 @@ void Configure::displayConfig()
     cout << "QtXmlPatterns support......." << dictionary[ "XMLPATTERNS" ] << endl;
     cout << "Phonon support.............." << dictionary[ "PHONON" ] << endl;
     cout << "WebKit support.............." << dictionary[ "WEBKIT" ] << endl;
+    cout << "Declarative support........." << dictionary[ "DECLARATIVE" ] << endl;
     cout << "QtScriptTools support......." << dictionary[ "SCRIPTTOOLS" ] << endl;
     cout << "Graphics System............." << dictionary[ "GRAPHICS_SYSTEM" ] << endl;
     cout << "Qt3 compatibility..........." << dictionary[ "QT3SUPPORT" ] << endl << endl;
diff --git a/tools/duiviewer/duiviewer.pro b/tools/duiviewer/duiviewer.pro
new file mode 100644
index 0000000..eae313e
--- /dev/null
+++ b/tools/duiviewer/duiviewer.pro
@@ -0,0 +1,12 @@
+DESTDIR = ../../bin
+QT += declarative script network sql
+# Input
+HEADERS += qfxviewer.h 
+SOURCES += main.cpp qfxviewer.cpp 
+
+include($$QT_SOURCE_TREE/tools/shared/deviceskin/deviceskin.pri)
+
+target.path=$$[QT_INSTALL_BINS]
+INSTALLS += target
+
+CONFIG += console
diff --git a/tools/duiviewer/main.cpp b/tools/duiviewer/main.cpp
new file mode 100644
index 0000000..cb4ba05
--- /dev/null
+++ b/tools/duiviewer/main.cpp
@@ -0,0 +1,135 @@
+/****************************************************************************
+**
+** Copyright (C) 1992-$THISYEAR$ $TROLLTECH$. All rights reserved.
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $TROLLTECH_DUAL_LICENSE$
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+#include "qml.h"
+#include "qfxviewer.h"
+#include <QWidget>
+#include <QDir>
+#include "qfxtestengine.h"
+#include <QApplication>
+
+
+void usage()
+{
+    qWarning("Usage: duiviewer [options] <filename>");
+    qWarning(" ");
+    qWarning(" options:");
+    qWarning("  -v, -version ............................. display version");
+    qWarning("  -frameless ............................... run with no window frame");
+    qWarning("  -skin <qvfbskindir> ...................... run with a skin window frame");
+    qWarning("  -recorddither ordered|threshold|floyd .... set dither mode used for recording");
+    qWarning("  -recordperiod <milliseconds> ............. set time between recording frames");
+    qWarning("  -autorecord [from-]<tomilliseconds> ...... set recording to start and stop automatically");
+    qWarning("  -devicekeys .............................. use numeric keys (see F1)");
+    qWarning("  -cache ................................... enable a disk cache of remote content");
+    qWarning("  -recordtest <directory> .................. record an autotest");
+    qWarning("  -runtest <directory> ..................... run a previously recorded test");
+    qWarning(" ");
+    qWarning(" Press F1 for interactive help");
+    exit(1);
+}
+
+int main(int argc, char ** argv)
+{
+    //### default to using raster graphics backend for now
+    int newargc = argc + 2;
+    char **newargv;
+    newargv = new char * [newargc];
+    for (int i = 0; i < argc; ++i) {
+        newargv[i] = argv[i];
+        if (!qstrcmp(argv[i], "-graphicssystem")) {
+            newargc -= 2;
+            break;
+        }
+    }
+    char system[] = "-graphicssystem";
+    newargv[argc] = system;
+    char raster[] = "raster";
+    newargv[argc+1] = raster;
+
+
+    QApplication app(newargc, newargv);
+    app.setApplicationName("viewer");
+
+    bool frameless = false;
+    QString fileName;
+    int period = 0;
+    int autorecord_from = 0;
+    int autorecord_to = 0;
+    QString dither = "threshold";
+    QString skin;
+    bool devkeys = false;
+    bool cache = false;
+    QFxTestEngine::TestMode testMode = QFxTestEngine::NoTest;
+    QString testDir;
+
+    for (int i = 1; i < newargc; ++i) {
+        QString arg = newargv[i];
+        if (arg == "-frameless") {
+            frameless = true;
+        } else if (arg == "-skin") {
+            skin = QString(argv[++i]);
+        } else if (arg == "-cache") {
+            cache = true;
+        } else if (arg == "-recordperiod") {
+            period = QString(argv[++i]).toInt();
+        } else if (arg == "-autorecord") {
+            QString range = QString(argv[++i]);
+            int dash = range.indexOf('-');
+            if (dash > 0)
+                autorecord_from = range.left(dash).toInt();
+            autorecord_to = range.mid(dash+1).toInt();
+        } else if (arg == "-devicekeys") {
+            devkeys = true;
+        } else if (arg == "-recordtest") {
+            testMode = QFxTestEngine::RecordTest;
+            if(i + 1 >= newargc) 
+                usage();
+            testDir = newargv[i + 1];
+            ++i;
+        } else if (arg == "-runtest") {
+            testMode = QFxTestEngine::PlaybackTest;
+            if(i + 1 >= newargc) 
+                usage();
+            testDir = newargv[i + 1];
+            ++i;
+        } else if (arg == QLatin1String("-v") || arg == QLatin1String("-version")) {
+            fprintf(stderr, "Qt Declarative UI Viewer version %s\n", QT_VERSION_STR);
+            return 0;
+        } else if (arg[0] != '-') {
+            fileName = arg;
+        } else if (1 || arg == "-help") {
+            usage();
+        }
+    }
+
+    if (fileName.isEmpty())
+        usage();
+
+    QFxViewer viewer(testMode, testDir, 0, frameless ? Qt::FramelessWindowHint : Qt::Widget);
+    viewer.setCacheEnabled(cache);
+    viewer.openXml(fileName);
+    if (period>0)
+        viewer.setRecordPeriod(period);
+    if (autorecord_to)
+        viewer.setAutoRecord(autorecord_from,autorecord_to);
+    if (QDir(skin).exists())
+        viewer.setSkin(skin);
+    if (devkeys)
+        viewer.setDeviceKeys(true);
+    viewer.setRecordDither(dither);
+    viewer.show();
+
+    return app.exec();
+}
+
diff --git a/tools/duiviewer/qfxviewer.cpp b/tools/duiviewer/qfxviewer.cpp
new file mode 100644
index 0000000..7b39f53
--- /dev/null
+++ b/tools/duiviewer/qfxviewer.cpp
@@ -0,0 +1,361 @@
+/****************************************************************************
+**
+** Copyright (C) 1992-$THISYEAR$ $TROLLTECH$. All rights reserved.
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $TROLLTECH_DUAL_LICENSE$
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+#include <qfxview.h>
+
+#include "qmlbindablevalue.h"
+#include "qfxviewer.h"
+#include <QtDeclarative/qmlcontext.h>
+#include <QtDeclarative/qmlengine.h>
+#include "qml.h"
+#include "qperformancelog.h"
+#include "qfxtestengine.h"
+#include "deviceskin.h"
+
+#include <QNetworkDiskCache>
+#include <QNetworkAccessManager>
+#include <QmlComponent>
+#include <QWidget>
+#include <QApplication>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QVBoxLayout>
+#include <QProcess>
+#include <QMenu>
+
+QFxViewer::QFxViewer(QFxTestEngine::TestMode testMode, const QString &testDir, QWidget *parent, Qt::WindowFlags flags)
+    : QWidget(parent, flags)
+{
+    testEngine = 0;
+    devicemode = false;
+    skin = 0;
+    canvas = 0;
+    record_autotime = 0;
+    record_period = 20;
+
+    int width=240;
+    int height=320;
+    setAttribute(Qt::WA_OpaquePaintEvent);
+    setAttribute(Qt::WA_NoSystemBackground);
+
+    canvas = new QFxView(this);
+    if(testMode != QFxTestEngine::NoTest)
+        testEngine = new QFxTestEngine(testMode, testDir, canvas, this);
+
+    QObject::connect(canvas, SIGNAL(sceneResized(QSize)), this, SLOT(sceneResized(QSize)));
+    canvas->setFixedSize(width, height);
+    setFixedSize(width, height);
+}
+
+void QFxViewer::reload()
+{
+    openXml(currentFileName);
+}
+
+void QFxViewer::openXml(const QString& fileName)
+{
+    setWindowTitle(tr("%1 - Qt Declarative UI Viewer").arg(fileName));
+
+    canvas->reset();
+
+    currentFileName = fileName;
+    QUrl url(fileName);
+    QFileInfo fi(fileName);
+    if (fi.exists()) {
+        url = QUrl::fromLocalFile(fi.absoluteFilePath());
+        QmlContext *ctxt = canvas->rootContext();
+        QDir dir(fi.path()+"/dummydata", "*.qml");
+        QStringList list = dir.entryList();
+        for (int i = 0; i < list.size(); ++i) {
+            QString qml = list.at(i);
+            QFile f(dir.filePath(qml));
+            f.open(QIODevice::ReadOnly);
+            QByteArray data = f.readAll();
+            QmlComponent comp(canvas->engine());
+            comp.setData(data, QUrl());
+            QObject *dummyData = comp.create();
+            if (dummyData) {
+                qWarning() << "Loaded dummy data:" << dir.filePath(qml);
+                qml.truncate(qml.length()-4);
+                ctxt->setContextProperty(qml, dummyData);
+                dummyData->setParent(this);
+            }
+        }
+    }
+
+    canvas->setUrl(url);
+
+    QTime t;
+    t.start();
+    canvas->execute();
+    qWarning() << "Wall startup time:" << t.elapsed();
+#ifdef QTOPIA
+    show();
+#endif
+}
+
+class PreviewDeviceSkin : public  DeviceSkin
+{
+    Q_OBJECT
+public:
+    explicit PreviewDeviceSkin(const DeviceSkinParameters &parameters, QWidget *parent);
+
+    void setPreview(QWidget *formWidget);
+    void setScreenSize(const QSize& size)
+    {
+        QMatrix fit;
+        fit = fit.scale(qreal(size.width())/m_screenSize.width(),
+            qreal(size.height())/m_screenSize.height());
+        setTransform(fit);
+    }
+
+private slots:
+    void slotSkinKeyPressEvent(int code, const QString& text, bool autorep);
+    void slotSkinKeyReleaseEvent(int code, const QString& text, bool autorep);
+    void slotPopupMenu();
+
+private:
+    void populateContextMenu(QMenu *menu);
+    const QSize m_screenSize;
+};
+
+
+PreviewDeviceSkin::PreviewDeviceSkin(const DeviceSkinParameters &parameters, QWidget *parent) :
+    DeviceSkin(parameters, parent),
+    m_screenSize(parameters.screenSize())
+{
+    connect(this, SIGNAL(skinKeyPressEvent(int,QString,bool)),
+            this, SLOT(slotSkinKeyPressEvent(int,QString,bool)));
+    connect(this, SIGNAL(skinKeyReleaseEvent(int,QString,bool)),
+            this, SLOT(slotSkinKeyReleaseEvent(int,QString,bool)));
+    connect(this, SIGNAL(popupMenu()), this, SLOT(slotPopupMenu()));
+}
+
+void PreviewDeviceSkin::setPreview(QWidget *formWidget)
+{
+    formWidget->setFixedSize(m_screenSize);
+    formWidget->setParent(this, Qt::SubWindow);
+    formWidget->setAutoFillBackground(true);
+    setView(formWidget);
+}
+
+void PreviewDeviceSkin::slotSkinKeyPressEvent(int code, const QString& text, bool autorep)
+{
+    if (QWidget *focusWidget =  QApplication::focusWidget()) {
+        QKeyEvent e(QEvent::KeyPress,code,0,text,autorep);
+        QApplication::sendEvent(focusWidget, &e);
+    }
+
+}
+
+void PreviewDeviceSkin::slotSkinKeyReleaseEvent(int code, const QString& text, bool autorep)
+{
+    if (QWidget *focusWidget =  QApplication::focusWidget()) {
+        QKeyEvent e(QEvent::KeyRelease,code,0,text,autorep);
+        QApplication::sendEvent(focusWidget, &e);
+    }
+}
+
+void PreviewDeviceSkin::slotPopupMenu()
+{
+    QMenu menu(this);
+    populateContextMenu(&menu);
+    menu.exec(QCursor::pos());
+}
+
+void PreviewDeviceSkin::populateContextMenu(QMenu *menu)
+{
+     connect(menu->addAction(tr("&Close")), SIGNAL(triggered()), parentWidget(), SLOT(close()));
+}
+
+
+void QFxViewer::setSkin(const QString& skinDirectory)
+{
+    DeviceSkinParameters parameters;
+    QString err;
+    if (parameters.read(skinDirectory,DeviceSkinParameters::ReadAll,&err)) {
+        delete skin;
+        if (!err.isEmpty())
+            qWarning() << err;
+        skin = new PreviewDeviceSkin(parameters,this);
+        skin->setScreenSize(canvas->size());
+        canvas->setParent(skin, Qt::SubWindow);
+        canvas->setAutoFillBackground(true);
+        skin->setView(canvas);
+        delete layout();
+
+        canvas->show();
+    }
+}
+
+void QFxViewer::setAutoRecord(int from, int to)
+{
+    record_autotime = to-from;
+    if (from) {
+        autoStartTimer.start(from,this);
+    } else {
+        autoTimer.start();
+        setRecording(true);
+    }
+}
+
+void QFxViewer::setRecordPeriod(int ms)
+{
+    record_period = ms;
+}
+
+void QFxViewer::sceneResized(QSize size)
+{
+    if(size.width() > 0 && size.height() > 0) {
+        canvas->setFixedSize(size.width(), size.height());
+        if (skin)
+            skin->setScreenSize(size);
+        else
+            setFixedSize(size);
+    }
+}
+
+void QFxViewer::keyPressEvent(QKeyEvent *event)
+{
+    if (event->key() == Qt::Key_0 && devicemode)
+        exit(0);
+    else if (event->key() == Qt::Key_F1 || (event->key() == Qt::Key_1 && devicemode)) {
+        qDebug() << "F1 - help\n"
+                 << "F2 - toggle GIF recording\n"
+                 << "F3 - take PNG snapshot\n"
+                 << "F4 - show items and state\n"
+                 << "F5 - reload XML\n"
+                 << "F6 - show object tree\n"
+                 << "F7 - show timing\n"
+                 << "F8 - show performance (if available)\n"
+                 << "device keys: 0=quit, 1..8=F1..F8"
+                ;
+    } else if (event->key() == Qt::Key_F2 || (event->key() == Qt::Key_2 && devicemode)) {
+        setRecording(!recordTimer.isActive());
+    } else if (event->key() == Qt::Key_F3 || (event->key() == Qt::Key_3 && devicemode)) {
+        setRecording(!recordTimer.isActive());
+        canvas->asImage().save("snapshot.png");
+        qDebug() << "Wrote snapshot.png";
+    } else if (event->key() == Qt::Key_F4 || (event->key() == Qt::Key_4 && devicemode)) {
+        canvas->dumpItems();
+        canvas->checkState();
+    } else if (event->key() == Qt::Key_F5 || (event->key() == Qt::Key_5 && devicemode)) {
+        reload();
+    } else if (event->key() == Qt::Key_F6 || (event->key() == Qt::Key_6 && devicemode)) {
+        canvas->dumpRoot();
+    } else if (event->key() == Qt::Key_F7 || (event->key() == Qt::Key_7 && devicemode)) {
+        canvas->dumpTiming();
+    } else if (event->key() == Qt::Key_F8 || (event->key() == Qt::Key_8 && devicemode)) {
+        QPerformanceLog::displayData();
+        QPerformanceLog::clear();
+    } else if (event->key() == Qt::Key_F9) {
+        if(testEngine) testEngine->save();
+    } else if (event->key() == Qt::Key_F10) {
+        if(testEngine) testEngine->captureFullFrame();
+    }
+
+    QWidget::keyPressEvent(event);
+}
+
+void QFxViewer::setRecording(bool on)
+{
+    if (on == recordTimer.isActive())
+        return;
+
+    if (on) {
+        recordTimer.start(record_period,this);
+    } else {
+        recordTimer.stop();
+        int frame=0;
+        QStringList inputs;
+        qDebug() << "Saving frames...";
+
+        foreach (QImage* img, frames) {
+            QString name;
+            name.sprintf("tmp-frame%04d.png",frame++);
+            if (record_dither=="ordered")
+                img->convertToFormat(QImage::Format_Indexed8,Qt::PreferDither|Qt::OrderedDither).save(name);
+            else if (record_dither=="threshold")
+                img->convertToFormat(QImage::Format_Indexed8,Qt::PreferDither|Qt::ThresholdDither).save(name);
+            else if (record_dither=="floyd")
+                img->convertToFormat(QImage::Format_Indexed8,Qt::PreferDither).save(name);
+            else
+                img->convertToFormat(QImage::Format_Indexed8).save(name);
+            inputs << name;
+            delete img;
+        }
+        QString output="animation.gif";
+
+        QStringList args;
+
+        args << "-delay" << QString::number(record_period/10);
+        args << inputs;
+        args << output;
+        qDebug() << "Converting..." << output;
+        if (0!=QProcess::execute("convert", args)) {
+            qWarning() << "Cannot run ImageMagick 'convert' - not converted to gif";
+            inputs.clear(); // don't remove them
+            qDebug() << "Wrote frames tmp-frame*.png";
+        } else {
+            qDebug() << "Compressing..." << output;
+            if (0!=QProcess::execute("gifsicle", QStringList() << "-O2" << "-o" << output << output))
+                qWarning() << "Cannot run 'gifsicle' - not compressed";
+            qDebug() << "Wrote" << output;
+        }
+
+        foreach (QString name, inputs)
+            QFile::remove(name);
+
+        frames.clear();
+    }
+    qDebug() << "Recording: " << (recordTimer.isActive()?"ON":"OFF");
+}
+
+void QFxViewer::timerEvent(QTimerEvent *event)
+{
+    if (event->timerId() == recordTimer.timerId()) {
+        frames.append(new QImage(canvas->asImage()));
+        if (record_autotime && autoTimer.elapsed() >= record_autotime)
+            setRecording(false);
+    } else if (event->timerId() == autoStartTimer.timerId()) {
+        autoTimer.start();
+        autoStartTimer.stop();
+        setRecording(true);
+    } else {
+        QWidget::timerEvent(event);
+    }
+}
+
+void QFxViewer::setDeviceKeys(bool on)
+{
+    devicemode = on;
+}
+
+void QFxViewer::setCacheEnabled(bool on)
+{
+    QNetworkAccessManager * nam = canvas->engine()->networkAccessManager();
+    if (on == !!nam->cache())
+        return;
+    if (on) {
+        // Setup a caching network manager
+        QNetworkDiskCache *cache = new QNetworkDiskCache;
+        cache->setCacheDirectory(QDir::tempPath()+QLatin1String("/qml-duiviewer-network-cache"));
+        cache->setMaximumCacheSize(8000000);
+        nam->setCache(cache);
+    } else {
+        nam->setCache(0);
+    }
+}
+
+#include "qfxviewer.moc"
diff --git a/tools/duiviewer/qfxviewer.h b/tools/duiviewer/qfxviewer.h
new file mode 100644
index 0000000..5733591
--- /dev/null
+++ b/tools/duiviewer/qfxviewer.h
@@ -0,0 +1,71 @@
+/****************************************************************************
+**
+** Copyright (C) 1992-$THISYEAR$ $TROLLTECH$. All rights reserved.
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $TROLLTECH_DUAL_LICENSE$
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+****************************************************************************/
+
+#ifndef QFXVIEWER_H
+#define QFXVIEWER_H
+
+#include <QWidget>
+#include <QBasicTimer>
+#include <QTime>
+#include <qfxtestengine.h>
+#include <QList>
+
+
+class QFxView;
+class PreviewDeviceSkin;
+class QFxTestEngine;
+
+class QFxViewer : public QWidget
+{
+Q_OBJECT
+public:
+    QFxViewer(QFxTestEngine::TestMode = QFxTestEngine::NoTest, const QString &testDir = QString(), QWidget *parent=0, Qt::WindowFlags flags=0);
+
+    void setRecordDither(const QString& s) { record_dither = s; }
+    void setRecordPeriod(int ms);
+    int recordPeriod() const { return record_period; }
+    void setRecording(bool on);
+    bool isRecording() const { return recordTimer.isActive(); }
+    void setAutoRecord(int from, int to);
+    void setSkin(const QString& skinDirectory);
+    void setDeviceKeys(bool);
+    void setCacheEnabled(bool);
+
+public slots:
+    void sceneResized(QSize size);
+    void openXml(const QString& fileName);
+    void reload();
+
+protected:
+    virtual void keyPressEvent(QKeyEvent *);
+    virtual void timerEvent(QTimerEvent *);
+
+private:
+    QString currentFileName;
+    PreviewDeviceSkin *skin;
+    QSize skinscreensize;
+    QFxView *canvas;
+    void init(QFxTestEngine::TestMode, const QString &, const QString& fileName);
+    QBasicTimer recordTimer;
+    QList<QImage*> frames;
+    QBasicTimer autoStartTimer;
+    QTime autoTimer;
+    QString record_dither;
+    int record_period;
+    int record_autotime;
+    bool devicemode;
+
+    QFxTestEngine *testEngine;
+};
+
+#endif
diff --git a/tools/qdoc3/codemarker.cpp b/tools/qdoc3/codemarker.cpp
index a803281..1b4b642 100644
--- a/tools/qdoc3/codemarker.cpp
+++ b/tools/qdoc3/codemarker.cpp
@@ -168,7 +168,8 @@ const Node *CodeMarker::nodeForString(const QString& string)
 {
     if (sizeof(const Node *) == sizeof(uint)) {
         return reinterpret_cast<const Node *>(string.toUInt());
-    } else {
+    }
+    else {
         return reinterpret_cast<const Node *>(string.toULongLong());
     }
 }
@@ -177,7 +178,8 @@ QString CodeMarker::stringForNode(const Node *node)
 {
     if (sizeof(const Node *) == sizeof(ulong)) {
         return QString::number(reinterpret_cast<ulong>(node));
-    } else {
+    }
+    else {
         return QString::number(reinterpret_cast<qulonglong>(node));
     }
 }
@@ -220,7 +222,8 @@ QString CodeMarker::typified(const QString &string)
             || ch.digitValue() >= 0 || ch == QLatin1Char('_')
                 || ch == QLatin1Char(':')) {
             pendingWord += ch;
-        } else {
+        }
+        else {
             if (!pendingWord.isEmpty()) {
                 bool isProbablyType = (pendingWord != QLatin1String("const"));
                 if (isProbablyType)
@@ -251,7 +254,7 @@ QString CodeMarker::typified(const QString &string)
     return result;
 }
 
-QString CodeMarker::taggedNode(const Node *node)
+QString CodeMarker::taggedNode(const Node* node)
 {
     QString tag;
 
@@ -276,11 +279,35 @@ QString CodeMarker::taggedNode(const Node *node)
         break;
     default:
         tag = QLatin1String("@unknown");
+        break;
     }
     return QLatin1Char('<') + tag + QLatin1Char('>') + protect(node->name())
         + QLatin1String("</") + tag + QLatin1Char('>');
 }
 
+#ifdef QDOC_QML
+QString CodeMarker::taggedQmlNode(const Node* node)
+{
+    QString tag;
+    switch (node->type()) {
+    case Node::QmlProperty:
+        tag = QLatin1String("@property");
+        break;
+    case Node::QmlSignal:
+        tag = QLatin1String("@signal");
+        break;
+    case Node::QmlMethod:
+        tag = QLatin1String("@method");
+        break;
+    default:
+        tag = QLatin1String("@unknown");
+        break;
+    }
+    return QLatin1Char('<') + tag + QLatin1Char('>') + protect(node->name())
+        + QLatin1String("</") + tag + QLatin1Char('>');
+}
+#endif
+
 QString CodeMarker::linkTag(const Node *node, const QString& body)
 {
     return QLatin1String("<@link node=\"") + stringForNode(node)
@@ -308,9 +335,11 @@ QString CodeMarker::sortName(const Node *node)
         QString sortNo;
         if (func->metaness() == FunctionNode::Ctor) {
             sortNo = QLatin1String("C");
-        } else if (func->metaness() == FunctionNode::Dtor) {
+        }
+        else if (func->metaness() == FunctionNode::Dtor) {
             sortNo = QLatin1String("D");
-        } else {
+        }
+        else {
             if (nodeName.startsWith(QLatin1String("operator"))
                     && nodeName.length() > 8
                     && !nodeName[8].isLetterOrNumber())
@@ -331,21 +360,32 @@ QString CodeMarker::sortName(const Node *node)
     return QLatin1Char('B') + nodeName;
 }
 
-void CodeMarker::insert(FastSection &fastSection, Node *node, SynopsisStyle style, Status status)
+void CodeMarker::insert(FastSection &fastSection,
+                        Node *node,
+                        SynopsisStyle style,
+                        Status status)
 {
-    bool inheritedMember = (!node->relates() &&
-			    (node->parent() != (const InnerNode *)fastSection.innerNode));
     bool irrelevant = false;
+    bool inheritedMember = false;
+    if (!node->relates()) {
+        if (node->parent() != (const InnerNode*)fastSection.innerNode) {
+            if (node->type() != Node::QmlProperty)
+                inheritedMember = true;
+        }
+    }
 
     if (node->access() == Node::Private) {
 	irrelevant = true;
-    } else if (node->type() == Node::Function) {
+    }
+    else if (node->type() == Node::Function) {
 	FunctionNode *func = (FunctionNode *) node;
 	irrelevant = (inheritedMember
 		      && (func->metaness() == FunctionNode::Ctor ||
 			  func->metaness() == FunctionNode::Dtor));
-    } else if (node->type() == Node::Class || node->type() == Node::Enum
-		    || node->type() == Node::Typedef) {
+    }
+    else if ((node->type() == Node::Class) ||
+             (node->type() == Node::Enum) ||
+             (node->type() == Node::Typedef)) {
 	irrelevant = (inheritedMember && style != SeparateList);
         if (!irrelevant && style == Detailed && node->type() == Node::Typedef) {
             const TypedefNode* typedeffe = static_cast<const TypedefNode*>(node);
@@ -357,9 +397,11 @@ void CodeMarker::insert(FastSection &fastSection, Node *node, SynopsisStyle styl
     if (!irrelevant) {
         if (status == Compat) {
             irrelevant = (node->status() != Node::Compat);
-	} else if (status == Obsolete) {
+	}
+        else if (status == Obsolete) {
             irrelevant = (node->status() != Node::Obsolete);
-	} else {
+	}
+        else {
             irrelevant = (node->status() == Node::Compat ||
                           node->status() == Node::Obsolete);
 	}
@@ -368,9 +410,11 @@ void CodeMarker::insert(FastSection &fastSection, Node *node, SynopsisStyle styl
     if (!irrelevant) {
 	if (!inheritedMember || style == SeparateList) {
 	    QString key = sortName(node);
-            if (!fastSection.memberMap.contains(key))
-		fastSection.memberMap.insert(key, node);
-	} else {
+            if (!fastSection.memberMap.contains(key)) {
+		fastSection.memberMap.insert(key,node);
+            }
+	}
+        else {
 	    if (node->parent()->type() == Node::Class) {
 		if (fastSection.inherited.isEmpty()
                     || fastSection.inherited.last().first != node->parent()) {
@@ -428,7 +472,8 @@ QStringList CodeMarker::macRefsForNode(const Node *node)
 #if 0
             if (!classe->templateStuff().isEmpty()) {
                  result += QLatin1String("tmplt/");
-            } else
+            }
+            else
 #endif
             {
                  result += QLatin1String("cl/");
@@ -465,14 +510,18 @@ QStringList CodeMarker::macRefsForNode(const Node *node)
                 result += QLatin1String("macro/");
                 isMacro = true;
 #if 0
-            } else if (!func->templateStuff().isEmpty()) {
+            }
+            else if (!func->templateStuff().isEmpty()) {
                 result += QLatin1String("ftmplt/");
 #endif
-            } else if (func->isStatic()) {
+            }
+            else if (func->isStatic()) {
                 result += QLatin1String("clm/");
-            } else if (!func->parent()->name().isEmpty()) {
+            }
+            else if (!func->parent()->name().isEmpty()) {
                 result += QLatin1String("instm/");
-            } else {
+            }
+            else {
                 result += QLatin1String("func/");
             }
 
@@ -486,7 +535,8 @@ QStringList CodeMarker::macRefsForNode(const Node *node)
                 result += "/" + QLatin1String(QMetaObject::normalizedSignature(func->returnType().toLatin1().constData())) + "/(";
                 const QList<Parameter> &params = func->parameters();
                 for (int i = 0; i < params.count(); ++i) {
-                    QString type = params.at(i).leftType() + params.at(i).rightType();
+                    QString type = params.at(i).leftType() +
+                        params.at(i).rightType();
                     type = QLatin1String(QMetaObject::normalizedSignature(type.toLatin1().constData()));
                     if (i != 0)
                         result += ",";
@@ -529,10 +579,21 @@ QString CodeMarker::macName(const Node *node, const QString &name)
 
     if (node->name().isEmpty()) {
         return QLatin1Char('/') + myName;
-    } else {
+    }
+    else {
         return plainFullName(node) + QLatin1Char('/') + myName;
     }
 }
 
+#ifdef QDOC_QML
+/*!
+  Get the list of documentation sections for the children of
+  the specified QmlClassNode.
+ */
+QList<Section> CodeMarker::qmlSections(const QmlClassNode* , SynopsisStyle )
+{
+    return QList<Section>();
+}
+#endif
 
 QT_END_NAMESPACE
diff --git a/tools/qdoc3/codemarker.h b/tools/qdoc3/codemarker.h
index 2bb1f2b..37cb449 100644
--- a/tools/qdoc3/codemarker.h
+++ b/tools/qdoc3/codemarker.h
@@ -114,6 +114,9 @@ class CodeMarker
     virtual QString markedUpSynopsis(const Node *node, 
                                      const Node *relative,
                                      SynopsisStyle style) = 0;
+#ifdef QDOC_QML
+    virtual QString markedUpQmlItem(const Node* , bool) { return QString(); }
+#endif
     virtual QString markedUpName(const Node *node) = 0;
     virtual QString markedUpFullName(const Node *node,
                                      const Node *relative = 0) = 0;
@@ -125,6 +128,10 @@ class CodeMarker
     virtual QList<Section> sections(const InnerNode *inner, 
                                     SynopsisStyle style, 
                                     Status status) = 0;
+#ifdef QDOC_QML
+    virtual QList<Section> qmlSections(const QmlClassNode* qmlClassNode,
+                                       SynopsisStyle style);
+#endif
     virtual const Node *resolveTarget(const QString& target, 
                                       const Tree *tree,
 		                      const Node *relative) = 0;
@@ -144,7 +151,10 @@ class CodeMarker
     virtual QString sortName(const Node *node);
     QString protect(const QString &string);
     QString typified(const QString &string);
-    QString taggedNode(const Node *node);
+    QString taggedNode(const Node* node);
+#ifdef QDOC_QML
+    QString taggedQmlNode(const Node* node);
+#endif
     QString linkTag(const Node *node, const QString& body);
     void insert(FastSection &fastSection, 
                 Node *node, 
diff --git a/tools/qdoc3/command.cpp b/tools/qdoc3/command.cpp
index a82494d..e121202 100644
--- a/tools/qdoc3/command.cpp
+++ b/tools/qdoc3/command.cpp
@@ -49,44 +49,46 @@
 
 QT_BEGIN_NAMESPACE
 
-void executeCommand( const Location& location, const QString& format,
-		     const QStringList& args )
+void executeCommand(const Location& location,
+                    const QString& format,
+                    const QStringList& args)
 {
     QString actualCommand;
-    for ( int i = 0; i < (int) format.length(); i++ ) {
+    for (int i = 0; i < (int) format.length(); i++) {
 	int ch = format[i].unicode();
-	if ( ch > 0 && ch < 8 ) {
+	if (ch > 0 && ch < 8) {
 	    actualCommand += args[ch - 1];
-	} else {
+	}
+        else {
 	    actualCommand += format[i];
 	}
     }
 
     QString toolName = actualCommand;
-    int space = toolName.indexOf( QLatin1Char(' ') );
-    if ( space != -1 )
-	toolName.truncate( space );
+    int space = toolName.indexOf(QLatin1Char(' '));
+    if (space != -1)
+	toolName.truncate(space);
 
     QProcess process;
     process.start(QLatin1String("sh"),
-        QStringList() << QLatin1String("-c") << actualCommand );
+        QStringList() << QLatin1String("-c") << actualCommand);
     process.waitForFinished();
 
     if (process.exitCode() == 127)
-	location.fatal( tr("Couldn't launch the '%1' tool")
-			.arg(toolName),
-			tr("Make sure the tool is installed and in the"
-			   " path.") );
+	location.fatal(tr("Couldn't launch the '%1' tool")
+                       .arg(toolName),
+                       tr("Make sure the tool is installed and in the"
+                          " path."));
 
     QString errors = QString::fromLocal8Bit(process.readAllStandardError());
-    while ( errors.endsWith(QLatin1Char('\n')) )
-        errors.truncate( errors.length() - 1 );
-    if ( !errors.isEmpty() )
-	location.fatal( tr("The '%1' tool encountered some problems")
-			.arg(toolName),
-			tr("The tool was invoked like this:\n%1\n"
-			   "It emitted these errors:\n%2")
-			.arg(actualCommand).arg(errors) );
+    while (errors.endsWith(QLatin1Char('\n')))
+        errors.truncate(errors.length() - 1);
+    if (!errors.isEmpty())
+	location.fatal(tr("The '%1' tool encountered some problems")
+                       .arg(toolName),
+                       tr("The tool was invoked like this:\n%1\n"
+                          "It emitted these errors:\n%2")
+                       .arg(actualCommand).arg(errors));
 }
 
 QT_END_NAMESPACE
diff --git a/tools/qdoc3/cppcodemarker.cpp b/tools/qdoc3/cppcodemarker.cpp
index 59b967b..0f35c5d 100644
--- a/tools/qdoc3/cppcodemarker.cpp
+++ b/tools/qdoc3/cppcodemarker.cpp
@@ -43,6 +43,7 @@
   cppcodemarker.cpp
 */
 
+#include <QtCore>
 #include "atom.h"
 #include "cppcodemarker.h"
 #include "node.h"
@@ -283,7 +284,7 @@ QString CppCodeMarker::markedUpSynopsis(const Node *node,
             }
             else {
                 for (int i = 0; i < documentedItems.size(); ++i) {
-		    if (i < MaxEnumValues - 2 || i == documentedItems.size() - 1) {
+		    if (i < MaxEnumValues-2 || i == documentedItems.size()-1) {
 	                if (i != 0)
 		            synopsis += ", ";
 		        synopsis += documentedItems.at(i);
@@ -344,6 +345,43 @@ QString CppCodeMarker::markedUpSynopsis(const Node *node,
     return synopsis + extra;
 }
 
+#ifdef QDOC_QML
+/*!
+ */
+QString CppCodeMarker::markedUpQmlItem(const Node* node, bool summary)
+{
+    QString name = taggedQmlNode(node);
+    if (summary) {
+	name = linkTag(node,name);
+    }
+    name = "<@name>" + name + "</@name>";
+    QString synopsis = name;
+    if (node->type() == Node::QmlProperty) {
+        const QmlPropertyNode* pn = static_cast<const QmlPropertyNode*>(node);
+        synopsis += " : " + typified(pn->dataType());
+    }
+
+    QString extra;
+    if (summary) {
+	if (node->status() == Node::Preliminary) {
+	    extra += " (preliminary)";
+	}
+        else if (node->status() == Node::Deprecated) {
+	    extra += " (deprecated)";
+	}
+        else if (node->status() == Node::Obsolete) {
+	    extra += " (obsolete)";
+	}
+    }
+
+    if (!extra.isEmpty()) {
+	extra.prepend("<@extra>");
+	extra.append("</@extra>");
+    }
+    return synopsis + extra;
+}
+#endif
+
 QString CppCodeMarker::markedUpName(const Node *node)
 {
     QString name = linkTag(node, taggedNode(node));
@@ -421,29 +459,73 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
         const ClassNode *classe = static_cast<const ClassNode *>(inner);
 
         if (style == Summary) {
-	    FastSection privateFunctions(classe, "Private Functions", "private function",
+	    FastSection privateFunctions(classe,
+                                         "Private Functions",
+                                         "private function",
 				         "private functions");
-	    FastSection privateSlots(classe, "Private Slots", "private slot", "private slots");
-	    FastSection privateTypes(classe, "Private Types", "private type", "private types");
-	    FastSection protectedFunctions(classe, "Protected Functions", "protected function",
+	    FastSection privateSlots(classe,
+                                     "Private Slots",
+                                     "private slot",
+                                     "private slots");
+	    FastSection privateTypes(classe,
+                                     "Private Types",
+                                     "private type",
+                                     "private types");
+	    FastSection protectedFunctions(classe,
+                                           "Protected Functions",
+                                           "protected function",
 				           "protected functions");
-	    FastSection protectedSlots(classe, "Protected Slots", "protected slot", "protected slots");
-	    FastSection protectedTypes(classe, "Protected Types", "protected type", "protected types");
-	    FastSection protectedVariables(classe, "Protected Variables", "protected type", "protected variables");
-	    FastSection publicFunctions(classe, "Public Functions", "public function",
+	    FastSection protectedSlots(classe,
+                                       "Protected Slots",
+                                       "protected slot",
+                                       "protected slots");
+	    FastSection protectedTypes(classe,
+                                       "Protected Types",
+                                       "protected type",
+                                       "protected types");
+	    FastSection protectedVariables(classe,
+                                           "Protected Variables",
+                                           "protected type",
+                                           "protected variables");
+	    FastSection publicFunctions(classe,
+                                        "Public Functions",
+                                        "public function",
 				        "public functions");
-	    FastSection publicSignals(classe, "Signals", "signal", "signals");
-	    FastSection publicSlots(classe, "Public Slots", "public slot", "public slots");
-	    FastSection publicTypes(classe, "Public Types", "public type", "public types");
-	    FastSection publicVariables(classe, "Public Variables", "public type", "public variables");
-	    FastSection properties(classe, "Properties", "property", "properties");
-	    FastSection relatedNonMembers(classe, "Related Non-Members", "related non-member",
+	    FastSection publicSignals(classe,
+                                      "Signals",
+                                      "signal",
+                                      "signals");
+	    FastSection publicSlots(classe,
+                                    "Public Slots",
+                                    "public slot",
+                                    "public slots");
+	    FastSection publicTypes(classe,
+                                    "Public Types",
+                                    "public type",
+                                    "public types");
+	    FastSection publicVariables(classe,
+                                        "Public Variables",
+                                        "public type",
+                                        "public variables");
+	    FastSection properties(classe,
+                                   "Properties",
+                                   "property",
+                                   "properties");
+	    FastSection relatedNonMembers(classe,
+                                          "Related Non-Members",
+                                          "related non-member",
                                           "related non-members");
-	    FastSection staticPrivateMembers(classe, "Static Private Members", "static private member",
+	    FastSection staticPrivateMembers(classe,
+                                             "Static Private Members",
+                                             "static private member",
 					     "static private members");
-	    FastSection staticProtectedMembers(classe, "Static Protected Members",
-					       "static protected member", "static protected members");
-	    FastSection staticPublicMembers(classe, "Static Public Members", "static public member",
+	    FastSection staticProtectedMembers(classe,
+                                               "Static Protected Members",
+					       "static protected member",
+                                               "static protected members");
+	    FastSection staticPublicMembers(classe,
+                                            "Static Public Members",
+                                            "static public member",
 					    "static public members");
             FastSection macros(inner, "Macros", "macro", "macros");
 
@@ -495,7 +577,7 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
                         else if (isStatic) {
                             if ((*c)->type() != Node::Variable
                                     || !(*c)->doc().isEmpty())
-		                insert(staticPublicMembers, *c, style, status);
+		                insert(staticPublicMembers,*c,style,status);
 		        }
                         else if ((*c)->type() == Node::Property) {
                             insert(properties, *c, style, status);
@@ -518,11 +600,11 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
                         else if (isStatic) {
                             if ((*c)->type() != Node::Variable
                                     || !(*c)->doc().isEmpty())
-		                insert(staticProtectedMembers, *c, style, status);
+		                insert(staticProtectedMembers,*c,style,status);
 		        }
                         else if ((*c)->type() == Node::Variable) {
                             if (!(*c)->doc().isEmpty())
-                                insert(protectedVariables, *c, style, status);
+                                insert(protectedVariables,*c,style,status);
 		        }
                         else if ((*c)->type() == Node::Function) {
 		            insert(protectedFunctions, *c, style, status);
@@ -538,13 +620,13 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
                         else if (isStatic) {
                             if ((*c)->type() != Node::Variable
                                     || !(*c)->doc().isEmpty())
-		                insert(staticPrivateMembers, *c, style, status);
+		                insert(staticPrivateMembers,*c,style,status);
 		        }
                         else if ((*c)->type() == Node::Function) {
-		            insert(privateFunctions, *c, style, status);
+		            insert(privateFunctions,*c,style,status);
 		        }
                         else {
-		            insert(privateTypes, *c, style, status);
+		            insert(privateTypes,*c,style,status);
 		        }
 	            }
 	            ++c;
@@ -661,17 +743,23 @@ QList<Section> CppCodeMarker::sections(const InnerNode *inner,
                                    "Namespaces",
                                    "namespace",
                                    "namespaces");
-            FastSection classes(inner, "Classes", "class", "classes");
+            FastSection classes(inner,
+                                "Classes",
+                                "class",
+                                "classes");
             FastSection types(inner,
-                              style == Summary ? "Types" : "Type Documentation",
+                              style == Summary ?
+                              "Types" : "Type Documentation",
                               "type",
 			      "types");
             FastSection functions(inner,
-                                  style == Summary ? "Functions" : "Function Documentation",
+                                  style == Summary ?
+                                  "Functions" : "Function Documentation",
 			          "function",
                                   "functions");
             FastSection macros(inner,
-                               style == Summary ? "Macros" : "Macro Documentation",
+                               style == Summary ?
+                               "Macros" : "Macro Documentation",
                                "macro",
                                "macros");
 
@@ -1006,4 +1094,82 @@ QString CppCodeMarker::addMarkUp(const QString& protectedCode,
     return result;
 }
 
+#ifdef QDOC_QML
+/*!
+  This function is for documenting QML properties. It returns
+  the list of documentation sections for the children of the
+  \a qmlClassNode.
+
+  Currently, it only handles QML property groups.
+ */
+QList<Section> CppCodeMarker::qmlSections(const QmlClassNode* qmlClassNode,
+                                          SynopsisStyle style)
+{
+    QList<Section> sections;
+    if (qmlClassNode) {
+        if (style == Summary) {
+	    FastSection qmlproperties(qmlClassNode,
+                                      "QML Properties",
+                                      "property",
+                                      "properties");
+	    FastSection qmlsignals(qmlClassNode,
+                                "QML Signals",
+                                "signal",
+                                "signals");
+	    FastSection qmlmethods(qmlClassNode,
+                                   "QML Methods",
+                                   "method",
+                                   "methods");
+
+            NodeList::ConstIterator c = qmlClassNode->childNodes().begin();
+            while (c != qmlClassNode->childNodes().end()) {
+                if ((*c)->subType() == Node::QmlPropertyGroup) {
+                    const QmlPropGroupNode* qpgn = static_cast<const QmlPropGroupNode*>(*c);
+                    NodeList::ConstIterator p = qpgn->childNodes().begin();
+                    while (p != qpgn->childNodes().end()) {
+                        if ((*p)->type() == Node::QmlProperty) {
+                            insert(qmlproperties,*p,style,Okay);
+                        }
+                        ++p;
+                    }
+                }
+                else if ((*c)->type() == Node::QmlSignal) {
+                    insert(qmlsignals,*c,style,Okay);
+                }
+                else if ((*c)->type() == Node::QmlMethod) {
+                    insert(qmlmethods,*c,style,Okay);
+                }
+                ++c;
+            }
+	    append(sections,qmlproperties);
+	    append(sections,qmlsignals);
+	    append(sections,qmlmethods);
+        }
+        else if (style == Detailed) {
+	    FastSection qmlproperties(qmlClassNode,"QML Property Documentation");
+	    FastSection qmlsignals(qmlClassNode,"QML Signal Documentation");
+	    FastSection qmlmethods(qmlClassNode,"QML Method Documentation");
+	    NodeList::ConstIterator c = qmlClassNode->childNodes().begin();
+	    while (c != qmlClassNode->childNodes().end()) {
+                if ((*c)->subType() == Node::QmlPropertyGroup) {
+		    insert(qmlproperties,*c,style,Okay);
+	        }
+                else if ((*c)->type() == Node::QmlSignal) {
+                    insert(qmlsignals,*c,style,Okay);
+                }
+                else if ((*c)->type() == Node::QmlMethod) {
+                    insert(qmlmethods,*c,style,Okay);
+                }
+	        ++c;
+	    }
+	    append(sections,qmlproperties);
+	    append(sections,qmlsignals);
+	    append(sections,qmlmethods);
+        }
+    }
+
+    return sections;
+}
+#endif
+
 QT_END_NAMESPACE
diff --git a/tools/qdoc3/cppcodemarker.h b/tools/qdoc3/cppcodemarker.h
index 8b68bc0..b4c2b43 100644
--- a/tools/qdoc3/cppcodemarker.h
+++ b/tools/qdoc3/cppcodemarker.h
@@ -67,6 +67,9 @@ class CppCodeMarker : public CodeMarker
     QString markedUpSynopsis(const Node *node, 
                              const Node *relative,
                              SynopsisStyle style);
+#ifdef QDOC_QML
+    QString markedUpQmlItem(const Node *node, bool summary);
+#endif
     QString markedUpName(const Node *node);
     QString markedUpFullName(const Node *node, const Node *relative);
     QString markedUpEnumValue(const QString &enumValue, const Node *relative);
@@ -76,6 +79,8 @@ class CppCodeMarker : public CodeMarker
     QList<Section> sections(const InnerNode *innerNode, 
                             SynopsisStyle style, 
                             Status status);
+    QList<Section> qmlSections(const QmlClassNode* qmlClassNode,
+                               SynopsisStyle style);
     const Node *resolveTarget(const QString& target, 
                               const Tree *tree, 
                               const Node *relative);
diff --git a/tools/qdoc3/cppcodeparser.cpp b/tools/qdoc3/cppcodeparser.cpp
index 1ad5843..92d6cf9 100644
--- a/tools/qdoc3/cppcodeparser.cpp
+++ b/tools/qdoc3/cppcodeparser.cpp
@@ -87,6 +87,9 @@ QT_BEGIN_NAMESPACE
 #ifdef QDOC_QML
 #define COMMAND_QMLCLASS                Doc::alias("qmlclass")
 #define COMMAND_QMLPROPERTY             Doc::alias("qmlproperty")
+#define COMMAND_QMLINHERITS             Doc::alias("inherits")
+#define COMMAND_QMLSIGNAL               Doc::alias("qmlsignal")
+#define COMMAND_QMLMETHOD               Doc::alias("qmlmethod")
 #endif
 
 QStringList CppCodeParser::exampleFiles;
@@ -109,7 +112,8 @@ static void extractPageLinkAndDesc(const QString &arg,
         if (arg.contains(".html") && spaceAt != -1) {
             *link = arg.left(spaceAt).trimmed();
             *desc = arg.mid(spaceAt).trimmed();
-        } else {
+        }
+        else {
             *link = arg;
             *desc = arg;
         }
@@ -202,11 +206,6 @@ void CppCodeParser::initializeParser(const Config &config)
     nodeTypeMap.insert(COMMAND_PROPERTY, Node::Property);
     nodeTypeMap.insert(COMMAND_VARIABLE, Node::Variable);
 
-#ifdef QDOC_QML
-    //    nodeTypeMap.insert(COMMAND_QMLCLASS, Node::Class);
-    nodeTypeMap.insert(COMMAND_QMLPROPERTY, Node::Property);
-#endif    
-    
     exampleFiles = config.getStringList(CONFIG_EXAMPLES);
     exampleDirs = config.getStringList(CONFIG_EXAMPLEDIRS);
     QStringList exampleFilePatterns = config.getStringList(
@@ -477,13 +476,15 @@ QSet<QString> CppCodeParser::topicCommands()
                            << COMMAND_PROPERTY
                            << COMMAND_SERVICE
                            << COMMAND_TYPEDEF
-#ifdef QDOC_QML        
+#ifdef QDOC_QML
                            << COMMAND_VARIABLE
                            << COMMAND_QMLCLASS
-                           << COMMAND_QMLPROPERTY;
-#else    
+                           << COMMAND_QMLPROPERTY
+                           << COMMAND_QMLSIGNAL
+                           << COMMAND_QMLMETHOD;
+#else
                            << COMMAND_VARIABLE;
-#endif    
+#endif
 }
 
 /*!
@@ -587,7 +588,7 @@ Node *CppCodeParser::processTopicCommand(const Doc& doc,
           The command was neither "fn" nor "macro" .
          */
         // ### split(" ") hack is there to support header file syntax
-        QStringList paths = arg.split(" "); 
+        QStringList paths = arg.split(" ");
         QStringList path = paths[0].split("::");
         
 #if QDOC2DOX        
@@ -643,49 +644,166 @@ Node *CppCodeParser::processTopicCommand(const Doc& doc,
             }
         }
 
+        if (command == COMMAND_CLASS) {
+            if (paths.size() > 1) {
+                if (!paths[1].endsWith(".h")) {
+                    ClassNode*cnode = static_cast<ClassNode*>(node);
+                    cnode->setQmlElement(paths[1]);
+                }
+            }
+        }
         return node;
     }
     else if (command == COMMAND_EXAMPLE) {
-        FakeNode *fake = new FakeNode(tre->root(), arg, FakeNode::Example);
+        FakeNode *fake = new FakeNode(tre->root(), arg, Node::Example);
         createExampleFileNodes(fake);
         return fake;
     }
     else if (command == COMMAND_EXTERNALPAGE) {
-        return new FakeNode(tre->root(), arg, FakeNode::ExternalPage);
+        return new FakeNode(tre->root(), arg, Node::ExternalPage);
     }
     else if (command == COMMAND_FILE) {
-        return new FakeNode(tre->root(), arg, FakeNode::File);
+        return new FakeNode(tre->root(), arg, Node::File);
     }
     else if (command == COMMAND_GROUP) {
-        return new FakeNode(tre->root(), arg, FakeNode::Group);
+        return new FakeNode(tre->root(), arg, Node::Group);
     }
     else if (command == COMMAND_HEADERFILE) {
-        return new FakeNode(tre->root(), arg, FakeNode::HeaderFile);
+        return new FakeNode(tre->root(), arg, Node::HeaderFile);
     }
     else if (command == COMMAND_MODULE) {
-        return new FakeNode(tre->root(), arg, FakeNode::Module);
+        return new FakeNode(tre->root(), arg, Node::Module);
     }
     else if (command == COMMAND_PAGE) {
-        return new FakeNode(tre->root(), arg, FakeNode::Page);
+        return new FakeNode(tre->root(), arg, Node::Page);
     }
-#ifdef QDOC_QML    
+#ifdef QDOC_QML
     else if (command == COMMAND_QMLCLASS) {
         const ClassNode* classNode = 0;
-        QStringList names = arg.split(" "); 
-        //qDebug() << "QMLCLASS" << names;
+        QStringList names = arg.split(" ");
         if (names.size() > 1) {
             Node* n = tre->findNode(names[1].split("::"),Node::Class);
-            if (n) {
+            if (n)
                 classNode = static_cast<const ClassNode*>(n);
-                //qDebug() << "FOUND IT!" << classNode->name();
+        }
+        return new QmlClassNode(tre->root(), names[0], classNode);
+    }
+    else if ((command == COMMAND_QMLSIGNAL) ||
+             (command == COMMAND_QMLMETHOD)) {
+        QString element;
+        QString name;
+        QmlClassNode* qmlClass = 0;
+        if (splitQmlArg(arg,element,name)) {
+            Node* n = tre->findNode(QStringList(element),Node::Fake);
+            if (n && n->subType() == Node::QmlClass) {
+                qmlClass = static_cast<const QmlClassNode*>(n);
+                if (command == COMMAND_QMLSIGNAL)
+                    return new QmlSignalNode(qmlClass,name);
+                else
+                    return new QmlMethodNode(qmlClass,name);
             }
         }
-        return new QmlNode(tre->root(), names[0], classNode);
     }
-#endif    
+#endif
     return 0;
 }
 
+#ifdef QDOC_QML
+
+/*!
+  A QML property argument has the form...
+
+  <type> <element>::<name>
+
+  This function splits the argument into those three
+  parts, sets \a type, \a element, and \a property,
+  and returns true. If any of the parts isn't found,
+  a debug message is output and false is returned.
+ */
+bool CppCodeParser::splitQmlPropertyArg(const QString& arg,
+                                        QString& type,
+                                        QString& element,
+                                        QString& property)
+{
+    QStringList blankSplit = arg.split(" ");
+    if (blankSplit.size() > 1) {
+        type = blankSplit[0];
+        QStringList colonSplit(blankSplit[1].split("::"));
+        if (colonSplit.size() > 1) {
+            element = colonSplit[0];
+            property = colonSplit[1];
+            return true;
+        }
+        else
+            qDebug() << "Missing QML element name or property name";
+    }
+    else
+        qDebug() << "Missing QML property type or property path";
+    return false;
+}
+
+/*!
+  A QML signal or method argument has the form...
+
+  <element>::<name>
+
+  This function splits the argument into those two
+  parts, sets \a element, and \a name, and returns
+  true. If either of the parts isn't found, a debug
+  message is output and false is returned.
+ */
+bool CppCodeParser::splitQmlArg(const QString& arg,
+                                QString& element,
+                                QString& name)
+{
+    QStringList colonSplit(arg.split("::"));
+    if (colonSplit.size() > 1) {
+        element = colonSplit[0];
+        name = colonSplit[1];
+        return true;
+    }
+    else
+        qDebug() << "Missing QML element name or signal/method name";
+    return false;
+}
+
+/*!
+  Process the topic \a command group with arguments \a args.
+
+  Currently, this function is called only for \e{qmlproperty}.
+ */
+Node *CppCodeParser::processTopicCommandGroup(const QString& command,
+                                              const QStringList& args)
+{
+    QmlPropGroupNode* qmlPropGroup = 0;
+    if (command == COMMAND_QMLPROPERTY) {
+        QString type;
+        QString element;
+        QString property;
+        QStringList::ConstIterator arg = args.begin();
+        if (splitQmlPropertyArg(*arg,type,element,property)) {
+            Node* n = tre->findNode(QStringList(element),Node::Fake);
+            if (n && n->subType() == Node::QmlClass) {
+                QmlClassNode* qmlClass = static_cast<QmlClassNode*>(n);
+                if (qmlClass)
+                    qmlPropGroup = new QmlPropGroupNode(qmlClass,property);
+            }
+        }
+        if (qmlPropGroup) {
+            new QmlPropertyNode(qmlPropGroup,property,type);
+            ++arg;
+            while (arg != args.end()) {
+                if (splitQmlPropertyArg(*arg,type,element,property)) {
+                    new QmlPropertyNode(qmlPropGroup,property,type);
+                }
+                ++arg;
+            }
+        }
+    }
+    return qmlPropGroup;
+}
+#endif
+
 /*!
   Returns the set of strings representing the common metacommands
   plus some other metacommands.
@@ -700,7 +818,12 @@ QSet<QString> CppCodeParser::otherMetaCommands()
                                 << COMMAND_NEXTPAGE
                                 << COMMAND_PREVIOUSPAGE
                                 << COMMAND_INDEXPAGE
+#ifdef QDOC_QML        
+                                << COMMAND_STARTPAGE
+                                << COMMAND_QMLINHERITS;
+#else    
                                 << COMMAND_STARTPAGE;
+#endif    
 }
 
 /*!
@@ -799,6 +922,11 @@ void CppCodeParser::processOtherMetaCommand(const Doc& doc,
     else if (command == COMMAND_STARTPAGE) {
         setLink(node, Node::StartLink, arg);
     }
+#ifdef QDOC_QML
+    else if (command == COMMAND_QMLINHERITS) {
+        setLink(node, Node::InheritsLink, arg);
+    }
+#endif
     else {
         processCommonMetaCommand(doc.location(),command,arg,node,tre);
     }
@@ -878,9 +1006,8 @@ bool CppCodeParser::match(int target)
         readToken();
         return true;
     }
-    else {
+    else
         return false;
-    }
 }
 
 /*!
@@ -915,11 +1042,14 @@ bool CppCodeParser::matchTemplateAngles(CodeChunk *dataType)
         do {
             if (tok == Tok_LeftAngle) {
                 leftAngleDepth++;
-            } else if (tok == Tok_RightAngle) {
+            }
+            else if (tok == Tok_RightAngle) {
                 leftAngleDepth--;
-            } else if (tok == Tok_LeftParen || tok == Tok_LeftBrace) {
+            }
+            else if (tok == Tok_LeftParen || tok == Tok_LeftBrace) {
                 ++parenAndBraceDepth;
-            } else if (tok == Tok_RightParen || tok == Tok_RightBrace) {
+            }
+            else if (tok == Tok_RightParen || tok == Tok_RightBrace) {
                 if (--parenAndBraceDepth < 0)
                     return false;
             }
@@ -982,7 +1112,8 @@ bool CppCodeParser::matchDataType(CodeChunk *dataType, QString *var)
                 dataType->append(previousLexeme());
             else
                 return false;
-        } else if (match(Tok_int) || match(Tok_char) || match(Tok_double)) {
+        }
+        else if (match(Tok_int) || match(Tok_char) || match(Tok_double)) {
             dataType->append(previousLexeme());
         }
 
@@ -1082,8 +1213,10 @@ bool CppCodeParser::matchParameter(FunctionNode *func)
             readToken();
         }
     }
-    func->addParameter(Parameter(dataType.toString(), "", name,
-                                  defaultValue.toString())); // ###
+    func->addParameter(Parameter(dataType.toString(),
+                                 "",
+                                 name,
+                                 defaultValue.toString())); // ###
     return true;
 }
 
@@ -1131,7 +1264,8 @@ bool CppCodeParser::matchFunctionDecl(InnerNode *parent,
         compat = true;
 
     if (tok == Tok_operator &&
-         (returnType.toString().isEmpty() || returnType.toString().endsWith("::"))) {
+         (returnType.toString().isEmpty() ||
+          returnType.toString().endsWith("::"))) {
         // 'QString::operator const char *()'
         parentPath = returnType.toString().split(sep);
         parentPath.removeAll(QString());
@@ -1167,11 +1301,10 @@ bool CppCodeParser::matchFunctionDecl(InnerNode *parent,
             name = previousLexeme();
             matchTemplateAngles();
 
-            if (match(Tok_Gulbrandsen)) {
+            if (match(Tok_Gulbrandsen))
                 parentPath.append(name);
-            } else {
+            else
                 break;
-            }
         }
 
         if (tok == Tok_operator) {
@@ -1184,7 +1317,9 @@ bool CppCodeParser::matchFunctionDecl(InnerNode *parent,
                     break;
             }
         }
-        if (parent && (tok == Tok_Semicolon || tok == Tok_LeftBracket || tok == Tok_Colon)
+        if (parent && (tok == Tok_Semicolon ||
+                       tok == Tok_LeftBracket ||
+                       tok == Tok_Colon)
                 && access != Node::Private) {
             if (tok == Tok_LeftBracket) {
                 returnType.appendHotspot();
@@ -1198,7 +1333,8 @@ bool CppCodeParser::matchFunctionDecl(InnerNode *parent,
                 }
                 if (tok != Tok_Semicolon)
                     return false;
-            } else if (tok == Tok_Colon) {
+            }
+            else if (tok == Tok_Colon) {
                 returnType.appendHotspot();
 
                 while (tok != Tok_Semicolon && tok != Tok_Eoi) {
@@ -1390,7 +1526,7 @@ bool CppCodeParser::matchNamespaceDecl(InnerNode *parent)
     QString namespaceName = previousLexeme();
     NamespaceNode *namespasse = 0;
     if (parent)
-        namespasse = static_cast<NamespaceNode *>(parent->findNode(namespaceName, Node::Namespace));
+        namespasse = static_cast<NamespaceNode*>(parent->findNode(namespaceName, Node::Namespace));
     if (!namespasse) {
         namespasse = new NamespaceNode(parent, namespaceName);
         namespasse->setAccess(access);
@@ -1456,7 +1592,8 @@ bool CppCodeParser::matchEnumItem(InnerNode *parent, EnumNode *enume)
         if (strVal.isEmpty()) {
             if (enume->items().isEmpty()) {
                 strVal = "0";
-            } else {
+            }
+            else {
                 QString last = enume->items().last().value();
                 bool ok;
                 int n = last.toInt(&ok);
@@ -1466,15 +1603,16 @@ bool CppCodeParser::matchEnumItem(InnerNode *parent, EnumNode *enume)
                             strVal = last.left(2) + QString::number(n + 1, 16);
                         else
                             strVal = "0" + QString::number(n + 1, 8);
-                    } else {
-                        strVal = QString::number(n + 1);
                     }
+                    else
+                        strVal = QString::number(n + 1);
                 }
             }
         }
 
         enume->addItem(EnumItem(name, strVal));
-    } else {
+    }
+    else {
         VariableNode *var = new VariableNode(parent, name);
         var->setAccess(access);
         var->setLocation(location());
@@ -1562,7 +1700,8 @@ bool CppCodeParser::matchProperty(InnerNode *parent)
 
         if (match(Tok_Ident)) {
             value = previousLexeme();
-        } else if (match(Tok_LeftParen)) {
+        }
+        else if (match(Tok_LeftParen)) {
             int depth = 1;
             while (tok != Tok_Eoi) {
                 if (tok == Tok_LeftParen) {
@@ -1821,6 +1960,28 @@ bool CppCodeParser::matchDocsAndStuff()
                 /*
                   There is a topic command. Process it.
                  */
+#ifdef QDOC_QML
+                if (topic == COMMAND_QMLPROPERTY) {
+                    Doc nodeDoc = doc;
+                    Node *node = processTopicCommandGroup(topic, args);
+                    if (node != 0) {
+                        nodes.append(node);
+                        docs.append(nodeDoc);
+                    }
+                }
+                else {
+                    QStringList::ConstIterator a = args.begin();
+                    while (a != args.end()) {
+                        Doc nodeDoc = doc;
+                        Node *node = processTopicCommand(nodeDoc, topic, *a);
+                        if (node != 0) {
+                            nodes.append(node);
+                            docs.append(nodeDoc);
+                        }
+                        ++a;
+                    }
+                }
+#else
                 QStringList::ConstIterator a = args.begin();
                 while (a != args.end()) {
                     Doc nodeDoc = doc;
@@ -1831,6 +1992,7 @@ bool CppCodeParser::matchDocsAndStuff()
                     }
                     ++a;
                 }
+#endif                
             }
 
             NodeList::Iterator n = nodes.begin();
@@ -1838,7 +2000,8 @@ bool CppCodeParser::matchDocsAndStuff()
             while (n != nodes.end()) {
                 processOtherMetaCommands(*d, *n);
                 (*n)->setDoc(*d);
-                if ((*n)->isInnerNode() && ((InnerNode *)*n)->includes().isEmpty()) {
+                if ((*n)->isInnerNode() &&
+                    ((InnerNode *)*n)->includes().isEmpty()) {
                     InnerNode *m = static_cast<InnerNode *>(*n);
                     while (m->parent() != tre->root())
                         m = m->parent();
@@ -1926,7 +2089,8 @@ void CppCodeParser::parseQiteratorDotH(const Location &location,
         mutableSequentialIteratorDefinition = lines[1];
         associativeIteratorDefinition = lines[2];
         mutableAssociativeIteratorDefinition = lines[3];
-    } else {
+    }
+    else {
         location.warning(tr("The qiterator.h hack failed"));
     }
 }
@@ -2008,7 +2172,7 @@ void CppCodeParser::createExampleFileNodes(FakeNode *fake)
     foreach (const QString &exampleFile, exampleFiles)
         (void) new FakeNode(fake,
                             exampleFile.mid(sizeOfBoringPartOfName),
-                            FakeNode::File);
+                            Node::File);
 }
 
 QT_END_NAMESPACE
diff --git a/tools/qdoc3/cppcodeparser.h b/tools/qdoc3/cppcodeparser.h
index e672654..2eb2fb3 100644
--- a/tools/qdoc3/cppcodeparser.h
+++ b/tools/qdoc3/cppcodeparser.h
@@ -90,6 +90,18 @@ class CppCodeParser : public CodeParser
     virtual Node *processTopicCommand(const Doc& doc, 
                                       const QString& command,
                                       const QString& arg);
+#ifdef QDOC_QML    
+    // might need to implement this in QsCodeParser as well.
+    virtual Node *processTopicCommandGroup(const QString& command,
+                                           const QStringList& args);
+    bool splitQmlPropertyArg(const QString& arg,
+                             QString& type,
+                             QString& element,
+                             QString& property);
+    bool splitQmlArg(const QString& arg,
+                     QString& element,
+                     QString& name);
+#endif
     virtual QSet<QString> otherMetaCommands();
     virtual void processOtherMetaCommand(const Doc& doc,
                                          const QString& command,
diff --git a/tools/qdoc3/doc.cpp b/tools/qdoc3/doc.cpp
index 61d0ed6..601d0bc 100644
--- a/tools/qdoc3/doc.cpp
+++ b/tools/qdoc3/doc.cpp
@@ -4662,7 +4662,7 @@ void DoxWriter::readAnchors()
 void DoxWriter::insertTitle(FakeNode* node, const QString& title)
 {
     switch (node->subType()) {
-    case FakeNode::Example:
+    case Node::Example:
         if (exampleTitles.contains(title)) {
             qWarning() << "DoxWriter::insertTitle():"
                        << "Duplicate example title:"
@@ -4673,7 +4673,7 @@ void DoxWriter::insertTitle(FakeNode* node, const QString& title)
             exampleTitlesInverse[node->name()] = title;
         }
         break;
-    case FakeNode::HeaderFile: 
+    case Node::HeaderFile: 
         if (headerFileTitles.contains(title)) {
             qWarning() << "DoxWriter::insertTitle():"
                        << "Duplicate header file title:"
@@ -4684,7 +4684,7 @@ void DoxWriter::insertTitle(FakeNode* node, const QString& title)
             headerFileTitlesInverse[node->name()] = title;
         }
         break;
-    case FakeNode::File:
+    case Node::File:
         if (fileTitles.contains(title)) {
             qWarning() << "DoxWriter::insertTitle():"
                        << "Duplicate file title:"
@@ -4695,7 +4695,7 @@ void DoxWriter::insertTitle(FakeNode* node, const QString& title)
             fileTitlesInverse[node->name()] = title;
         }
         break;
-    case FakeNode::Group:
+    case Node::Group:
         if (groupTitles.contains(title)) {
             qWarning() << "DoxWriter::insertTitle():"
                        << "Duplicate group title:"
@@ -4706,7 +4706,7 @@ void DoxWriter::insertTitle(FakeNode* node, const QString& title)
             groupTitlesInverse[node->name()] = title;
         }
         break;
-    case FakeNode::Module:
+    case Node::Module:
         if (moduleTitles.contains(title)) {
             qWarning() << "DoxWriter::insertTitle():"
                        << "Duplicate module title:"
@@ -4717,7 +4717,7 @@ void DoxWriter::insertTitle(FakeNode* node, const QString& title)
             moduleTitlesInverse[node->name()] = title;
         }
         break;
-    case FakeNode::Page:
+    case Node::Page:
         if (pageTitles.contains(title)) {
             qWarning() << "DoxWriter::insertTitle():"
                        << "Duplicate page title:"
@@ -4728,7 +4728,7 @@ void DoxWriter::insertTitle(FakeNode* node, const QString& title)
             pageTitlesInverse[node->name()] = title;
         }
         break;
-    case FakeNode::ExternalPage:
+    case Node::ExternalPage:
         if (externalPageTitles.contains(title)) {
             qWarning() << "DoxWriter::insertTitle():"
                        << "Duplicate external page title:"
diff --git a/tools/qdoc3/generator.cpp b/tools/qdoc3/generator.cpp
index d89d6af..f299420 100644
--- a/tools/qdoc3/generator.cpp
+++ b/tools/qdoc3/generator.cpp
@@ -42,7 +42,7 @@
 /*
   generator.cpp
 */
-
+#include <QtCore>
 #include <qdir.h>
 
 #include "codemarker.h"
@@ -70,12 +70,18 @@ QString Generator::project;
 
 static Text stockLink(const QString &target)
 {
-    return Text() << Atom(Atom::Link, target) << Atom(Atom::FormattingLeft, ATOM_FORMATTING_LINK)
-                  << target << Atom(Atom::FormattingRight, ATOM_FORMATTING_LINK);
+    return Text() << Atom(Atom::Link, target)
+                  << Atom(Atom::FormattingLeft, ATOM_FORMATTING_LINK)
+                  << target
+                  << Atom(Atom::FormattingRight, ATOM_FORMATTING_LINK);
 }
 
 Generator::Generator()
-    : amp("&amp;"), lt("&lt;"), gt("&gt;"), quot("&quot;"), tag("</?@[^>]*>")
+    : amp("&amp;"),
+      lt("&lt;"),
+      gt("&gt;"),
+      quot("&quot;"),
+      tag("</?@[^>]*>")
 {
     generators.prepend(this);
 }
@@ -123,7 +129,8 @@ void Generator::initialize(const Config &config)
     QSet<QString> formats = config.subVars(imagesDotFileExtensions);
     QSet<QString>::ConstIterator f = formats.begin();
     while (f != formats.end()) {
-        imgFileExts[*f] = config.getStringList(imagesDotFileExtensions + Config::dot + *f);
+        imgFileExts[*f] = config.getStringList(imagesDotFileExtensions +
+                                               Config::dot + *f);
         ++f;
     }
 
@@ -131,16 +138,22 @@ void Generator::initialize(const Config &config)
     while (g != generators.end()) {
         if (outputFormats.contains((*g)->format())) {
             (*g)->initializeGenerator(config);
-            QStringList extraImages = config.getStringList(CONFIG_EXTRAIMAGES + Config::dot
-                                                           + (*g)->format());
+            QStringList extraImages = config.getStringList(CONFIG_EXTRAIMAGES +
+                                                           Config::dot +
+                                                           (*g)->format());
             QStringList::ConstIterator e = extraImages.begin();
             while (e != extraImages.end()) {
                 QString userFriendlyFilePath;
-                QString filePath = Config::findFile(config.lastLocation(), imageFiles, imageDirs, *e,
-                                                    imgFileExts[(*g)->format()], userFriendlyFilePath);
+                QString filePath = Config::findFile(config.lastLocation(),
+                                                    imageFiles, imageDirs, *e,
+                                                    imgFileExts[(*g)->format()],
+                                                    userFriendlyFilePath);
                 if (!filePath.isEmpty())
-                    Config::copyFile(config.lastLocation(), filePath, userFriendlyFilePath,
-                                         (*g)->outputDir() + "/images");
+                    Config::copyFile(config.lastLocation(),
+                                     filePath,
+                                     userFriendlyFilePath,
+                                     (*g)->outputDir() +
+                                     "/images");
                 ++e;
             }
         }
@@ -156,20 +169,23 @@ void Generator::initialize(const Config &config)
         QSet<QString> formats = config.subVars(formattingDotName);
         QSet<QString>::ConstIterator f = formats.begin();
         while (f != formats.end()) {
-            QString def = config.getString(formattingDotName + Config::dot +
-                                            *f);
+            QString def = config.getString(formattingDotName +
+                                           Config::dot + *f);
             if (!def.isEmpty()) {
                 int numParams = Config::numParams(def);
                 int numOccs = def.count("\1");
 
                 if (numParams != 1) {
-                    config.lastLocation().warning(tr("Formatting '%1' must have exactly one"
-                                                     " parameter (found %2)")
-                                                 .arg(*n).arg(numParams));
+                    config.lastLocation().warning(tr("Formatting '%1' must "
+                                                     "have exactly one "
+                                                     "parameter (found %2)")
+                                                  .arg(*n).arg(numParams));
                 }
                 else if (numOccs > 1) {
-                    config.lastLocation().fatal(tr("Formatting '%1' must contain exactly one"
-                                                    " occurrence of '\\1' (found %2)")
+                    config.lastLocation().fatal(tr("Formatting '%1' must "
+                                                   "contain exactly one "
+                                                   "occurrence of '\\1' "
+                                                   "(found %2)")
                                                 .arg(*n).arg(numOccs));
                 }
                 else {
@@ -258,20 +274,33 @@ void Generator::generateText(const Text& text,
 }
 
 #ifdef QDOC_QML
+/*!
+  Extract sections of markup text surrounded by \e qmltext
+  and \e endqmltext and output them.
+ */
 void Generator::generateQmlText(const Text& text,
                                 const Node *relative,
-                                CodeMarker *marker)
+                                CodeMarker *marker,
+                                const QString& qmlName)
 {
     if (text.firstAtom() != 0) {
         startText(relative, marker);
         const Atom *atom = text.firstAtom();
         while (atom) {
-            if (atom->type() != Atom::QmlText)
+            if (atom->type() != Atom::QmlText) {
                 atom = atom->next();
+            }
             else {
+                int n = 0;
                 atom = atom->next();
                 while (atom && (atom->type() != Atom::EndQmlText)) {
-                    int n = 1 + generateAtom(atom, relative, marker);
+                    if (atom->string() == relative->name()) {
+                        Atom renamed(*atom);
+                        renamed.setString(qmlName);
+                        n = 1 + generateAtom(&renamed, relative, marker);
+                    }
+                    else
+                        n = 1 + generateAtom(atom, relative, marker);
                     while (n-- > 0)
                         atom = atom->next();
                 }
@@ -295,9 +324,9 @@ void Generator::generateBody(const Node *node, CodeMarker *marker)
     }
     else if (node->type() == Node::Fake) {
         const FakeNode *fake = static_cast<const FakeNode *>(node);
-        if (fake->subType() == FakeNode::Example)
+        if (fake->subType() == Node::Example)
             generateExampleFiles(fake, marker);
-        else if (fake->subType() == FakeNode::File)
+        else if (fake->subType() == Node::File)
             quiet = true;
     }
 
@@ -382,7 +411,8 @@ void Generator::generateBody(const Node *node, CodeMarker *marker)
                             FunctionNode *primaryFunc =
                                     func->parent()->findFunctionNode(func->name());
                             if (primaryFunc) {
-                                foreach (const Parameter &param, primaryFunc->parameters()) {
+                                foreach (const Parameter &param,
+                                         primaryFunc->parameters()) {
                                     if (param.name() == *a) {
                                         needWarning = false;
                                         break;
@@ -392,7 +422,8 @@ void Generator::generateBody(const Node *node, CodeMarker *marker)
                         }
                         if (needWarning)
                             node->doc().location().warning(
-                                tr("Undocumented parameter '%1' in %2").arg(*a).arg(marker->plainFullName(node)));
+                                tr("Undocumented parameter '%1' in %2")
+                                .arg(*a).arg(marker->plainFullName(node)));
                     }
                     ++a;
                 }
@@ -412,7 +443,7 @@ void Generator::generateBody(const Node *node, CodeMarker *marker)
 
     if (node->type() == Node::Fake) {
         const FakeNode *fake = static_cast<const FakeNode *>(node);
-        if (fake->subType() == FakeNode::File) {
+        if (fake->subType() == Node::File) {
             Text text;
             Quoter quoter;
             Doc::quoteFromFile(fake->doc().location(), quoter, fake->name());
@@ -459,7 +490,8 @@ void Generator::generateInherits(const ClassNode *classe, CodeMarker *marker)
 
             if ((*r).access == Node::Protected) {
                 text << " (protected)";
-            } else if ((*r).access == Node::Private) {
+            }
+            else if ((*r).access == Node::Private) {
                 text << " (private)";
             }
             text << separator(index++, classe->baseClasses().count());
@@ -470,6 +502,15 @@ void Generator::generateInherits(const ClassNode *classe, CodeMarker *marker)
     }
 }
 
+#ifdef QDOC_QML
+/*!
+ */
+void Generator::generateQmlInherits(const QmlClassNode* , CodeMarker* )
+{
+    // stub.
+}
+#endif
+
 void Generator::generateInheritedBy(const ClassNode *classe,
                                     CodeMarker *marker)
 {
@@ -497,18 +538,21 @@ void Generator::generateExampleFiles(const FakeNode *fake, CodeMarker *marker)
         QString exampleFile = child->name();
         openedList.next();
         text << Atom(Atom::ListItemNumber, openedList.numberString())
-             << Atom(Atom::ListItemLeft, openedList.styleString()) << Atom::ParaLeft
+             << Atom(Atom::ListItemLeft, openedList.styleString())
+             << Atom::ParaLeft
              << Atom(Atom::Link, exampleFile)
              << Atom(Atom::FormattingLeft, ATOM_FORMATTING_LINK)
              << exampleFile
              << Atom(Atom::FormattingRight, ATOM_FORMATTING_LINK)
-             << Atom::ParaRight << Atom(Atom::ListItemRight, openedList.styleString());
+             << Atom::ParaRight
+             << Atom(Atom::ListItemRight, openedList.styleString());
     }
     text << Atom(Atom::ListRight, openedList.styleString());
     generateText(text, fake, marker);
 }
 
-void Generator::generateModuleWarning(const ClassNode *classe, CodeMarker *marker)
+void Generator::generateModuleWarning(const ClassNode *classe,
+                                      CodeMarker *marker)
 {
     QString module = classe->moduleName();
     if (!module.isEmpty()) {
@@ -529,8 +573,10 @@ void Generator::generateModuleWarning(const ClassNode *classe, CodeMarker *marke
                  << Atom(Atom::FormattingRight, ATOM_FORMATTING_BOLD)
                  << Atom::ParaRight;
         }
-        else if (module == "Qt3Support" && Tokenizer::isTrue("defined(opensourceedition)")) {
-            text << Atom::ParaLeft << Atom(Atom::FormattingLeft, ATOM_FORMATTING_BOLD)
+        else if (module == "Qt3Support" &&
+                 Tokenizer::isTrue("defined(opensourceedition)")) {
+            text << Atom::ParaLeft
+                 << Atom(Atom::FormattingLeft, ATOM_FORMATTING_BOLD)
                  << "Note to Qt Desktop Light Edition users:"
                  << Atom(Atom::FormattingRight, ATOM_FORMATTING_BOLD)
                  << " This class is only available in the "
@@ -558,10 +604,12 @@ QString Generator::indent(int level, const QString& markedCode)
                 if (markedCode.at(i - 1) == QLatin1Char('>'))
                     break;
             }
-        } else {
+        }
+        else {
             if (markedCode.at(i) == QLatin1Char('\n')) {
                 column = 0;
-            } else {
+            }
+            else {
                 if (column == 0) {
                     for (int j = 0; j < level; j++)
                         t += QLatin1Char(' ');
@@ -630,7 +678,7 @@ void Generator::setImageFileExtensions(const QStringList& extensions)
 void Generator::unknownAtom(const Atom *atom)
 {
     Location::internalError(tr("unknown atom type '%1' in %2 generator")
-                             .arg(atom->typeString()).arg(format()));
+                            .arg(atom->typeString()).arg(format()));
 }
 
 bool Generator::matchAhead(const Atom *atom, Atom::Type expectedAtomType)
@@ -659,7 +707,8 @@ void Generator::supplementAlsoList(const Node *node, QList<Text> &alsoList)
                         alternateFunc = func->parent()->findFunctionNode(alternateName);
                     }
                 }
-            } else if (!func->name().isEmpty()) {
+            }
+            else if (!func->name().isEmpty()) {
                 alternateName = "set";
                 alternateName += func->name()[0].toUpper();
                 alternateName += func->name().mid(1);
@@ -715,9 +764,13 @@ void Generator::generateStatus(const Node *node, CodeMarker *marker)
     case Node::Main:
         break;
     case Node::Preliminary:
-        text << Atom::ParaLeft << Atom(Atom::FormattingLeft, ATOM_FORMATTING_BOLD) << "This "
-             << typeString(node) << " is under development and is subject to change."
-             << Atom(Atom::FormattingRight, ATOM_FORMATTING_BOLD) << Atom::ParaRight;
+        text << Atom::ParaLeft
+             << Atom(Atom::FormattingLeft, ATOM_FORMATTING_BOLD)
+             << "This "
+             << typeString(node)
+             << " is under development and is subject to change."
+             << Atom(Atom::FormattingRight, ATOM_FORMATTING_BOLD)
+             << Atom::ParaRight;
         break;
     case Node::Deprecated:
         text << Atom::ParaLeft;
@@ -735,16 +788,21 @@ void Generator::generateStatus(const Node *node, CodeMarker *marker)
         text << "This " << typeString(node) << " is obsolete.";
         if (node->isInnerNode())
             text << Atom(Atom::FormattingRight, ATOM_FORMATTING_BOLD);
-        text << " It is provided to keep old source code working. We strongly advise against "
+        text << " It is provided to keep old source code working. "
+             << "We strongly advise against "
              << "using it in new code." << Atom::ParaRight;
         break;
     case Node::Compat:
         // reimplemented in HtmlGenerator subclass
         if (node->isInnerNode()) {
-            text << Atom::ParaLeft << Atom(Atom::FormattingLeft, ATOM_FORMATTING_BOLD) << "This "
-                 << typeString(node) << " is part of the Qt 3 compatibility layer."
+            text << Atom::ParaLeft
+                 << Atom(Atom::FormattingLeft, ATOM_FORMATTING_BOLD)
+                 << "This "
+                 << typeString(node)
+                 << " is part of the Qt 3 compatibility layer."
                  << Atom(Atom::FormattingRight, ATOM_FORMATTING_BOLD)
-                 << " It is provided to keep old source code working. We strongly advise against "
+                 << " It is provided to keep old source code working. "
+                 << "We strongly advise against "
                  << "using it in new code. See "
                  << Atom(Atom::AutoLink, "Porting to Qt 4")
                  << " for more information."
@@ -768,16 +826,25 @@ void Generator::generateThreadSafeness(const Node *node, CodeMarker *marker)
     case Node::UnspecifiedSafeness:
         break;
     case Node::NonReentrant:
-        text << Atom::ParaLeft << Atom(Atom::FormattingLeft, ATOM_FORMATTING_BOLD) << "Warning:"
-             << Atom(Atom::FormattingRight, ATOM_FORMATTING_BOLD) << " This "
-             << typeString(node) << " is not " << stockLink("reentrant") << "." << Atom::ParaRight;
+        text << Atom::ParaLeft
+             << Atom(Atom::FormattingLeft, ATOM_FORMATTING_BOLD)
+             << "Warning:"
+             << Atom(Atom::FormattingRight, ATOM_FORMATTING_BOLD)
+             << " This "
+             << typeString(node)
+             << " is not "
+             << stockLink("reentrant")
+             << "."
+             << Atom::ParaRight;
         break;
     case Node::Reentrant:
     case Node::ThreadSafe:
-        text << Atom::ParaLeft << Atom(Atom::FormattingLeft, ATOM_FORMATTING_BOLD);
+        text << Atom::ParaLeft
+             << Atom(Atom::FormattingLeft, ATOM_FORMATTING_BOLD);
         if (parent == Node::ThreadSafe) {
             text << "Warning:";
-        } else {
+        }
+        else {
             text << "Note:";
         }
         text << Atom(Atom::FormattingRight, ATOM_FORMATTING_BOLD) << " ";
@@ -789,7 +856,9 @@ void Generator::generateThreadSafeness(const Node *node, CodeMarker *marker)
 
         if (node->isInnerNode()) {
             const InnerNode *innerNode = static_cast<const InnerNode *>(node);
-            text << "All the functions in this " << typeString(node) << " are "
+            text << "All the functions in this "
+                 << typeString(node)
+                 << " are "
                  << theStockLink;
 
             NodeList except;
@@ -815,7 +884,11 @@ void Generator::generateThreadSafeness(const Node *node, CodeMarker *marker)
             }
         }
         else {
-            text << "This " << typeString(node) << " is " << theStockLink << ".";
+            text << "This "
+                 << typeString(node)
+                 << " is "
+                 << theStockLink
+                 << ".";
         }
         text << Atom::ParaRight;
     }
@@ -826,7 +899,9 @@ void Generator::generateSince(const Node *node, CodeMarker *marker)
 {
     if (!node->since().isEmpty()) {
         Text text;
-        text << Atom::ParaLeft << "This " << typeString(node)
+        text << Atom::ParaLeft
+             << "This "
+             << typeString(node)
              << " was introduced in ";
         if (project.isEmpty())
              text << "version";
@@ -856,7 +931,8 @@ void Generator::generateReimplementedFrom(const FunctionNode *func,
 {
     if (func->reimplementedFrom() != 0) {
         const FunctionNode *from = func->reimplementedFrom();
-        if (from->access() != Node::Private && from->parent()->access() != Node::Private) {
+        if (from->access() != Node::Private &&
+            from->parent()->access() != Node::Private) {
             Text text;
             text << Atom::ParaLeft << "Reimplemented from ";
             appendFullName(text, from->parent(), func, marker, from);
@@ -897,8 +973,8 @@ const Atom *Generator::generateAtomList(const Atom *atom,
 
             if (atom->type() == Atom::FormatEndif) {
                 if (generate && numAtoms0 == numAtoms) {
-                    relative->location().warning(tr("Output format %1 not handled").
-                                                 arg(format()));
+                    relative->location().warning(tr("Output format %1 not handled")
+                                                 .arg(format()));
                     Atom unhandledFormatAtom(Atom::UnhandledFormat, format());
                     generateAtomList(&unhandledFormatAtom,
                                      relative,
@@ -909,7 +985,8 @@ const Atom *Generator::generateAtomList(const Atom *atom,
                 atom = atom->next();
             }
         }
-        else if (atom->type() == Atom::FormatElse || atom->type() == Atom::FormatEndif) {
+        else if (atom->type() == Atom::FormatElse ||
+                 atom->type() == Atom::FormatEndif) {
             return atom;
         }
         else {
@@ -950,7 +1027,8 @@ void Generator::appendSortedNames(Text& text,
 
     r = classes.begin();
     while (r != classes.end()) {
-        if ((*r).node->access() == Node::Public && (*r).node->status() != Node::Internal
+        if ((*r).node->access() == Node::Public &&
+            (*r).node->status() != Node::Internal
             && !(*r).node->doc().isEmpty()) {
             Text className;
             appendFullName(className, (*r).node, classe, marker);
diff --git a/tools/qdoc3/generator.h b/tools/qdoc3/generator.h
index 3db2d8d..9f42160 100644
--- a/tools/qdoc3/generator.h
+++ b/tools/qdoc3/generator.h
@@ -99,7 +99,10 @@ class Generator
 #ifdef QDOC_QML
     virtual void generateQmlText(const Text& text, 
                                  const Node *relative,
-                                 CodeMarker *marker);
+                                 CodeMarker *marker,
+                                 const QString& qmlName);
+    virtual void generateQmlInherits(const QmlClassNode* cn, 
+                                     CodeMarker* marker);
 #endif
     virtual void generateBody(const Node *node, CodeMarker *marker);
     virtual void generateAlsoList(const Node *node, CodeMarker *marker);
diff --git a/tools/qdoc3/helpprojectwriter.cpp b/tools/qdoc3/helpprojectwriter.cpp
index d0fa7c0..85bd898 100644
--- a/tools/qdoc3/helpprojectwriter.cpp
+++ b/tools/qdoc3/helpprojectwriter.cpp
@@ -118,16 +118,16 @@ void HelpProjectWriter::readSelectors(SubProject &subproject, const QStringList
     typeHash["variable"] = Node::Variable;
     typeHash["target"] = Node::Target;
 
-    QHash<QString, FakeNode::SubType> subTypeHash;
-    subTypeHash["example"] = FakeNode::Example;
-    subTypeHash["headerfile"] = FakeNode::HeaderFile;
-    subTypeHash["file"] = FakeNode::File;
-    subTypeHash["group"] = FakeNode::Group;
-    subTypeHash["module"] = FakeNode::Module;
-    subTypeHash["page"] = FakeNode::Page;
-    subTypeHash["externalpage"] = FakeNode::ExternalPage;
+    QHash<QString, Node::SubType> subTypeHash;
+    subTypeHash["example"] = Node::Example;
+    subTypeHash["headerfile"] = Node::HeaderFile;
+    subTypeHash["file"] = Node::File;
+    subTypeHash["group"] = Node::Group;
+    subTypeHash["module"] = Node::Module;
+    subTypeHash["page"] = Node::Page;
+    subTypeHash["externalpage"] = Node::ExternalPage;
 
-    QSet<FakeNode::SubType> allSubTypes = QSet<FakeNode::SubType>::fromList(subTypeHash.values());
+    QSet<Node::SubType> allSubTypes = QSet<Node::SubType>::fromList(subTypeHash.values());
 
     foreach (const QString &selector, selectors) {
         QStringList pieces = selector.split(":");
@@ -139,7 +139,7 @@ void HelpProjectWriter::readSelectors(SubProject &subproject, const QStringList
             QString lower = pieces[0].toLower();
             pieces = pieces[1].split(",");
             if (typeHash.contains(lower)) {
-                QSet<FakeNode::SubType> subTypes;
+                QSet<Node::SubType> subTypes;
                 for (int i = 0; i < pieces.size(); ++i) {
                     QString lower = pieces[i].toLower();
                     if (subTypeHash.contains(lower))
@@ -235,7 +235,7 @@ bool HelpProjectWriter::generateSection(HelpProject &project,
                 // mask.
                 const FakeNode *fakeNode = static_cast<const FakeNode *>(node);
                 if (subproject.selectors[node->type()].contains(fakeNode->subType()) &&
-                    fakeNode->subType() != FakeNode::ExternalPage &&
+                    fakeNode->subType() != Node::ExternalPage &&
                     !fakeNode->fullTitle().isEmpty())
 
                     project.subprojects[name].nodes[objName] = node;
@@ -324,10 +324,10 @@ bool HelpProjectWriter::generateSection(HelpProject &project,
         // attributes.
         case Node::Fake: {
             const FakeNode *fakeNode = static_cast<const FakeNode*>(node);
-            if (fakeNode->subType() != FakeNode::ExternalPage &&
+            if (fakeNode->subType() != Node::ExternalPage &&
                 !fakeNode->fullTitle().isEmpty()) {
 
-                if (fakeNode->subType() != FakeNode::File) {
+                if (fakeNode->subType() != Node::File) {
                     if (fakeNode->doc().hasKeywords()) {
                         foreach (const Atom *keyword, fakeNode->doc().keywords()) {
                             if (!keyword->string().isEmpty()) {
@@ -485,7 +485,7 @@ void HelpProjectWriter::writeNode(HelpProject &project, QXmlStreamWriter &writer
             writer.writeAttribute("title", fakeNode->fullTitle());
             //            qDebug() << "Title:" << fakeNode->fullTitle();
             
-            if (fakeNode->subType() == FakeNode::HeaderFile) {
+            if (fakeNode->subType() == Node::HeaderFile) {
 
                 // Write subsections for all members, obsolete members and Qt 3
                 // members.
@@ -609,7 +609,7 @@ void HelpProjectWriter::generateProject(HelpProject &project)
                     while (nextPage) {
                         writeNode(project, writer, nextPage);
                         nextTitle = nextPage->links().value(Node::NextLink).first;
-                        if (nextTitle.isEmpty())
+                        if(nextTitle.isEmpty())
                             break;
                         nextPage = const_cast<FakeNode *>(tree->findFakeNodeByTitle(nextTitle));
                     }
diff --git a/tools/qdoc3/htmlgenerator.cpp b/tools/qdoc3/htmlgenerator.cpp
index 13d52bf..9237fea 100644
--- a/tools/qdoc3/htmlgenerator.cpp
+++ b/tools/qdoc3/htmlgenerator.cpp
@@ -102,11 +102,21 @@ void HtmlGenerator::initializeGenerator(const Config &config)
         i++;
     }
 
-    style = config.getString(HtmlGenerator::format() + Config::dot + HTMLGENERATOR_STYLE);
-    postHeader = config.getString(HtmlGenerator::format() + Config::dot + HTMLGENERATOR_POSTHEADER);
-    footer = config.getString(HtmlGenerator::format() + Config::dot + HTMLGENERATOR_FOOTER);
-    address = config.getString(HtmlGenerator::format() + Config::dot + HTMLGENERATOR_ADDRESS);
-    pleaseGenerateMacRef = config.getBool(HtmlGenerator::format() + Config::dot + HTMLGENERATOR_GENERATEMACREFS);
+    style = config.getString(HtmlGenerator::format() +
+                             Config::dot +
+                             HTMLGENERATOR_STYLE);
+    postHeader = config.getString(HtmlGenerator::format() +
+                                  Config::dot +
+                                  HTMLGENERATOR_POSTHEADER);
+    footer = config.getString(HtmlGenerator::format() +
+                              Config::dot +
+                              HTMLGENERATOR_FOOTER);
+    address = config.getString(HtmlGenerator::format() +
+                               Config::dot +
+                               HTMLGENERATOR_ADDRESS);
+    pleaseGenerateMacRef = config.getBool(HtmlGenerator::format() +
+                                          Config::dot +
+                                          HTMLGENERATOR_GENERATEMACREFS);
 
     project = config.getString(CONFIG_PROJECT);
 
@@ -120,10 +130,16 @@ void HtmlGenerator::initializeGenerator(const Config &config)
     QSet<QString>::ConstIterator edition = editionNames.begin();
     while (edition != editionNames.end()) {
         QString editionName = *edition;
-        QStringList editionModules = config.getStringList(
-            CONFIG_EDITION + Config::dot + editionName + Config::dot + "modules");
-        QStringList editionGroups = config.getStringList(
-            CONFIG_EDITION + Config::dot + editionName + Config::dot + "groups");
+        QStringList editionModules = config.getStringList(CONFIG_EDITION +
+                                                          Config::dot +
+                                                          editionName +
+                                                          Config::dot +
+                                                          "modules");
+        QStringList editionGroups = config.getStringList(CONFIG_EDITION +
+                                                         Config::dot +
+                                                         editionName +
+                                                         Config::dot +
+                                                         "groups");
 
         if (!editionModules.isEmpty())
             editionModuleMap[editionName] = editionModules;
@@ -135,11 +151,17 @@ void HtmlGenerator::initializeGenerator(const Config &config)
 
     slow = config.getBool(CONFIG_SLOW);
 
-    stylesheets = config.getStringList(HtmlGenerator::format() + Config::dot + HTMLGENERATOR_STYLESHEETS);
-    customHeadElements = config.getStringList(HtmlGenerator::format() + Config::dot + HTMLGENERATOR_CUSTOMHEADELEMENTS);
+    stylesheets = config.getStringList(HtmlGenerator::format() +
+                                       Config::dot +
+                                       HTMLGENERATOR_STYLESHEETS);
+    customHeadElements = config.getStringList(HtmlGenerator::format() +
+                                              Config::dot +
+                                              HTMLGENERATOR_CUSTOMHEADELEMENTS);
     codeIndent = config.getInt(CONFIG_CODEINDENT);
 
-    helpProjectWriter = new HelpProjectWriter(config, project.toLower() + ".qhp");
+    helpProjectWriter = new HelpProjectWriter(config,
+                                              project.toLower() +
+                                              ".qhp");
 }
 
 void HtmlGenerator::terminateGenerator()
@@ -182,9 +204,9 @@ void HtmlGenerator::generateTree(const Tree *tree, CodeMarker *marker)
     findAllFunctions(tree->root());
     findAllLegaleseTexts(tree->root());
     findAllNamespaces(tree->root());
-#ifdef ZZZ_QDOC_QML    
+#ifdef ZZZ_QDOC_QML
     findAllQmlClasses(tree->root());
-#endif    
+#endif
 
     PageGenerator::generateTree(tree, marker);
 
@@ -288,7 +310,8 @@ int HtmlGenerator::generateAtom(const Atom *atom,
             QString str;
             atom = atom->next();
             while (atom != 0 && atom->type() != Atom::BriefRight) {
-                if (atom->type() == Atom::String || atom->type() == Atom::AutoLink)
+                if (atom->type() == Atom::String ||
+                    atom->type() == Atom::AutoLink)
                     str += atom->string();
                 skipAhead++;
                 atom = atom->next();
@@ -330,17 +353,23 @@ int HtmlGenerator::generateAtom(const Atom *atom,
                                                             marker, relative))
               << "</pre>\n";
 	break;
-#ifdef QDOC_QML        
+#ifdef QDOC_QML
     case Atom::Qml:
-	out() << "<pre>" << trimmedTrailing(highlightedCode(indent(codeIndent, atom->string()),
-                                                            marker, relative))
+	out() << "<pre>"
+              << trimmedTrailing(highlightedCode(indent(codeIndent,
+                                                        atom->string()),
+                                                 marker,
+                                                 relative))
               << "</pre>\n";
 	break;
-#endif        
+#endif
     case Atom::CodeNew:
         out() << "<p>you can rewrite it as</p>\n"
-              << "<pre>" << trimmedTrailing(highlightedCode(indent(codeIndent, atom->string()),
-                                                            marker, relative))
+              << "<pre>"
+              << trimmedTrailing(highlightedCode(indent(codeIndent,
+                                                        atom->string()),
+                                                 marker,
+                                                 relative))
               << "</pre>\n";
         break;
     case Atom::CodeOld:
@@ -840,7 +869,7 @@ int HtmlGenerator::generateAtom(const Atom *atom,
     case Atom::EndQmlText:
         // don't do anything with these. They are just tags.
         break;
-#endif        
+#endif
     default:
         unknownAtom(atom);
     }
@@ -906,6 +935,12 @@ void HtmlGenerator::generateClassLikeNode(const InnerNode *inner,
     generateHeader(title, inner, marker, true);
     generateTitle(title, subtitleText, SmallSubTitle, inner, marker);
 
+#ifdef QDOC_QML    
+    if (classe && !classe->qmlElement().isEmpty()) {
+        generateInstantiatedBy(classe,marker);
+    }
+#endif
+    
     generateBrief(inner, marker);
     generateIncludes(inner, marker);
     generateStatus(inner, marker);
@@ -924,12 +959,16 @@ void HtmlGenerator::generateClassLikeNode(const InnerNode *inner,
         out() << "<li><a href=\"" << membersLink << "\">"
               << "List of all members, including inherited members</a></li>\n";
 
-    QString obsoleteLink = generateLowStatusMemberFile(inner, marker, CodeMarker::Obsolete);
+    QString obsoleteLink = generateLowStatusMemberFile(inner,
+                                                       marker,
+                                                       CodeMarker::Obsolete);
     if (!obsoleteLink.isEmpty())
         out() << "<li><a href=\"" << obsoleteLink << "\">"
               << "Obsolete members</a></li>\n";
 
-    QString compatLink = generateLowStatusMemberFile(inner, marker, CodeMarker::Compat);
+    QString compatLink = generateLowStatusMemberFile(inner,
+                                                     marker,
+                                                     CodeMarker::Compat);
     if (!compatLink.isEmpty())
         out() << "<li><a href=\"" << compatLink << "\">"
               << "Qt 3 support members</a></li>\n";
@@ -944,8 +983,10 @@ void HtmlGenerator::generateClassLikeNode(const InnerNode *inner,
         if (s->members.isEmpty()) {
             if (!s->inherited.isEmpty())
                 needOtherSection = true;
-        } else {
-            out() << "<a name=\"" << registerRef((*s).name.toLower()) << "\"></a>\n";
+        }
+        else {
+            out() << "<a name=\"" << registerRef((*s).name.toLower())
+                  << "\"></a>\n";
             out() << "<h3>" << protect((*s).name) << "</h3>\n";
 
             generateSectionList(*s, inner, marker, CodeMarker::Summary);
@@ -996,30 +1037,38 @@ void HtmlGenerator::generateClassLikeNode(const InnerNode *inner,
                 QStringList names;
                 names << (*m)->name();
                 if ((*m)->type() == Node::Function) {
-                    const FunctionNode *func = reinterpret_cast<const FunctionNode *>(*m);
-                    if (func->metaness() == FunctionNode::Ctor || func->metaness() == FunctionNode::Dtor
+                    const FunctionNode *func =
+                        reinterpret_cast<const FunctionNode *>(*m);
+                    if (func->metaness() == FunctionNode::Ctor ||
+                        func->metaness() == FunctionNode::Dtor
                             || func->overloadNumber() != 1)
                         names.clear();
-                } else if ((*m)->type() == Node::Property) {
-                    const PropertyNode *prop = reinterpret_cast<const PropertyNode *>(*m);
-                    if (!prop->getters().isEmpty() && !names.contains(prop->getters().first()->name()))
+                }
+                else if ((*m)->type() == Node::Property) {
+                    const PropertyNode *prop =
+                        reinterpret_cast<const PropertyNode *>(*m);
+                    if (!prop->getters().isEmpty() &&
+                        !names.contains(prop->getters().first()->name()))
                         names << prop->getters().first()->name();
                     if (!prop->setters().isEmpty())
                         names << prop->setters().first()->name();
                     if (!prop->resetters().isEmpty())
                         names << prop->resetters().first()->name();
-                } else if ((*m)->type() == Node::Enum) {
-                    const EnumNode *enume = reinterpret_cast<const EnumNode *>(*m);
+                }
+                else if ((*m)->type() == Node::Enum) {
+                    const EnumNode *enume =
+                        reinterpret_cast<const EnumNode *>(*m);
                     if (enume->flagsType())
                         names << enume->flagsType()->name();
 
                     foreach (const QString &enumName,
                              enume->doc().enumItemNames().toSet()
                              - enume->doc().omitEnumItemNames().toSet())
-                        names << plainCode(marker->markedUpEnumValue(enumName, enume));
+                        names << plainCode(marker->markedUpEnumValue(enumName,
+                                                                     enume));
                 }
                 foreach (const QString &name, names)
-                    classSection.keywords += qMakePair(name, linkForNode(*m, 0));
+                    classSection.keywords += qMakePair(name,linkForNode(*m,0));
             }
             ++m;
         }
@@ -1060,16 +1109,19 @@ void HtmlGenerator::generateFakeNode(const FakeNode *fake, CodeMarker *marker)
     QList<Section>::const_iterator s;
 
     QString htmlTitle = fake->fullTitle();
-    if (fake->subType() == FakeNode::File && !fake->subTitle().isEmpty()) {
+    if (fake->subType() == Node::File && !fake->subTitle().isEmpty()) {
         subTitleSize = SmallSubTitle;
         htmlTitle += " (" + fake->subTitle() + ")";
     }
 
     generateHeader(htmlTitle, fake, marker, true);
-    generateTitle(fake->fullTitle(), Text() << fake->subTitle(), subTitleSize,
-                  fake, marker);
+    generateTitle(fake->fullTitle(),
+                  Text() << fake->subTitle(),
+                  subTitleSize,
+                  fake,
+                  marker);
 
-    if (fake->subType() == FakeNode::Module) {
+    if (fake->subType() == Node::Module) {
         // Generate brief text and status for modules.
         generateBrief(fake, marker);
         generateStatus(fake, marker);
@@ -1083,7 +1135,7 @@ void HtmlGenerator::generateFakeNode(const FakeNode *fake, CodeMarker *marker)
             generateAnnotatedList(fake, marker, moduleClassMap[fake->name()]);
         }
     }
-    else if (fake->subType() == FakeNode::HeaderFile) {
+    else if (fake->subType() == Node::HeaderFile) {
         // Generate brief text and status for modules.
         generateBrief(fake, marker);
         generateStatus(fake, marker);
@@ -1095,12 +1147,16 @@ void HtmlGenerator::generateFakeNode(const FakeNode *fake, CodeMarker *marker)
             out() << "<li><a href=\"" << membersLink << "\">"
                   << "List of all members, including inherited members</a></li>\n";
 
-        QString obsoleteLink = generateLowStatusMemberFile(fake, marker, CodeMarker::Obsolete);
+        QString obsoleteLink = generateLowStatusMemberFile(fake,
+                                                           marker,
+                                                           CodeMarker::Obsolete);
         if (!obsoleteLink.isEmpty())
             out() << "<li><a href=\"" << obsoleteLink << "\">"
                   << "Obsolete members</a></li>\n";
 
-        QString compatLink = generateLowStatusMemberFile(fake, marker, CodeMarker::Compat);
+        QString compatLink = generateLowStatusMemberFile(fake,
+                                                         marker,
+                                                         CodeMarker::Compat);
         if (!compatLink.isEmpty())
             out() << "<li><a href=\"" << compatLink << "\">"
                   << "Qt 3 support members</a></li>\n";
@@ -1126,7 +1182,49 @@ void HtmlGenerator::generateFakeNode(const FakeNode *fake, CodeMarker *marker)
             appendDcfSubSection(&fakeSection, compatSection);
         }
     }
+#ifdef QDOC_QML
+    else if (fake->subType() == Node::QmlClass) {
+        const QmlClassNode* qml_cn = static_cast<const QmlClassNode*>(fake);
+        const ClassNode* cn = qml_cn->classNode();
+        generateQmlInherits(qml_cn, marker);
+        generateQmlInstantiates(qml_cn, marker);
+        generateBrief(qml_cn, marker);
+        sections = marker->qmlSections(qml_cn,CodeMarker::Summary);
+        s = sections.begin();
+        while (s != sections.end()) {
+            out() << "<a name=\"" << registerRef((*s).name) << "\"></a>\n";
+            out() << "<h2>" << protect((*s).name) << "</h2>\n";
+            generateQmlSummary(*s,fake,marker);
+            ++s;
+        }
+
+        out() << "<a name=\"" << registerRef("details") << "\"></a>\n";
+        out() << "<h2>" << "Detailed Description" << "</h2>\n";
+        generateBody(fake, marker);
+        if (cn)
+            generateQmlText(cn->doc().body(), cn, marker, fake->name());
+        generateAlsoList(fake, marker);
+        out() << "<hr />\n";
 
+        sections = marker->qmlSections(qml_cn,CodeMarker::Detailed);
+        s = sections.begin();
+        while (s != sections.end()) {
+            out() << "<h2>" << protect((*s).name) << "</h2>\n";
+            NodeList::ConstIterator m = (*s).members.begin();
+            while (m != (*s).members.end()) {
+                generateDetailedQmlMember(*m, fake, marker);
+                out() << "<br />\n";
+                fakeSection.keywords += qMakePair((*m)->name(),
+                                                  linkForNode(*m,0));
+                ++m;
+            }
+            ++s;
+        }
+        generateFooter(fake);
+        return;
+    }
+#endif
+    
     sections = marker->sections(fake, CodeMarker::Summary, CodeMarker::Okay);
     s = sections.begin();
     while (s != sections.end()) {
@@ -1137,24 +1235,12 @@ void HtmlGenerator::generateFakeNode(const FakeNode *fake, CodeMarker *marker)
     }
 
     Text brief = fake->doc().briefText();
-    if (fake->subType() == FakeNode::Module && !brief.isEmpty()) {
+    if (fake->subType() == Node::Module && !brief.isEmpty()) {
         out() << "<a name=\"" << registerRef("details") << "\"></a>\n";
         out() << "<h2>" << "Detailed Description" << "</h2>\n";
     }
 
     generateBody(fake, marker);
-#ifdef QDOC_QML    
-    if (fake->subType() == FakeNode::QmlClass) {
-        //qDebug() << "generateFakeNode(): QML CLASS" << fake->name();
-        const QmlNode* qmlNode = static_cast<const QmlNode*>(fake);
-        const ClassNode* cn = qmlNode->classNode();
-        if (cn) {
-            //qDebug() << "  CPP CLASS" << cn->name();
-            generateQmlText(cn->doc().body(), cn, marker);
-        }
-    }
-#endif    
-
     generateAlsoList(fake, marker);
 
     if (!fake->groupMembers().isEmpty()) {
@@ -1184,10 +1270,10 @@ void HtmlGenerator::generateFakeNode(const FakeNode *fake, CodeMarker *marker)
     }
     generateFooter(fake);
 
-    if (fake->subType() == FakeNode::Example) {
+    if (fake->subType() == Node::Example) {
         appendDcfSubSection(&dcfExamplesRoot, fakeSection);
     }
-    else if (fake->subType() != FakeNode::File) {
+    else if (fake->subType() != Node::File) {
         QString contentsPage = fake->links().value(Node::ContentsLink).first;
 
         if (contentsPage == "Qt Designer Manual") {
@@ -1435,7 +1521,8 @@ void HtmlGenerator::generateTableOfContents(const Node *node, CodeMarker *marker
 
     QString tdTag;
     if (numColumns > 1) {
-        tdTag = "<td width=\"" + QString::number((100 + numColumns - 1) / numColumns) + "%\">";
+        tdTag = "<td width=\"" +
+            QString::number((100 + numColumns - 1) / numColumns) + "%\">";
         out() << "<p><table width=\"100%\">\n<tr valign=\"top\">" << tdTag << "\n";
     }
 
@@ -1455,7 +1542,8 @@ void HtmlGenerator::generateTableOfContents(const Node *node, CodeMarker *marker
                 out() << "<ul>";
                 sectionNumber.append("1");
             } while (sectionNumber.size() < nextLevel);
-        } else {
+        }
+        else {
             while (sectionNumber.size() > nextLevel) {
                 out() << "</ul>\n";
                 sectionNumber.removeLast();
@@ -1470,7 +1558,10 @@ void HtmlGenerator::generateTableOfContents(const Node *node, CodeMarker *marker
             columnSize = 0;
         }
         out() << "<li>";
-        out() << "<a href=\"" << nodeName << "#" << Doc::canonicalTitle(headingText.toString())
+        out() << "<a href=\""
+              << nodeName
+              << "#"
+              << Doc::canonicalTitle(headingText.toString())
               << "\">";
         generateAtomList(headingText.firstAtom(), node, marker, true, numAtoms);
         out() << "</a></li>\n";
@@ -1520,12 +1611,15 @@ void HtmlGenerator::generateNavigationBar(const NavigationBar& bar,
 }
 #endif
 
-QString HtmlGenerator::generateListOfAllMemberFile(const InnerNode *inner, CodeMarker *marker)
+QString HtmlGenerator::generateListOfAllMemberFile(const InnerNode *inner,
+                                                   CodeMarker *marker)
 {
     QList<Section> sections;
     QList<Section>::ConstIterator s;
 
-    sections = marker->sections(inner, CodeMarker::SeparateList, CodeMarker::Okay);
+    sections = marker->sections(inner,
+                                CodeMarker::SeparateList,
+                                CodeMarker::Okay);
     if (sections.isEmpty())
         return QString();
 
@@ -1546,10 +1640,13 @@ QString HtmlGenerator::generateListOfAllMemberFile(const InnerNode *inner, CodeM
     return fileName;
 }
 
-QString HtmlGenerator::generateLowStatusMemberFile(const InnerNode *inner, CodeMarker *marker,
+QString HtmlGenerator::generateLowStatusMemberFile(const InnerNode *inner,
+                                                   CodeMarker *marker,
                                                    CodeMarker::Status status)
 {
-    QList<Section> sections = marker->sections(inner, CodeMarker::Summary, status);
+    QList<Section> sections = marker->sections(inner,
+                                               CodeMarker::Summary,
+                                               status);
     QMutableListIterator<Section> j(sections);
     while (j.hasNext()) {
         if (j.next().members.size() == 0)
@@ -1566,7 +1663,8 @@ QString HtmlGenerator::generateLowStatusMemberFile(const InnerNode *inner, CodeM
     if (status == CodeMarker::Compat) {
         title = "Qt 3 Support Members for " + inner->name();
         fileName = fileBase(inner) + "-qt3." + fileExtension(inner);
-    } else {
+    }
+    else {
         title = "Obsolete Members for " + inner->name();
         fileName = fileBase(inner) + "-obsolete." + fileExtension(inner);
     }
@@ -1580,19 +1678,21 @@ QString HtmlGenerator::generateLowStatusMemberFile(const InnerNode *inner, CodeM
                  "<a href=\"qt3support.html\">Qt 3 support layer</a>.</b> "
                  "They are provided to help you port old code to Qt 4. We advise against "
                  "using them in new code.</p>\n";
-    } else {
-        out() << "<p><b>The following class members are obsolete.</b> They are provided to keep "
-                 "old source code working. We strongly advise against using them in new "
-                 "code.</p>\n";
+    }
+    else {
+        out() << "<p><b>The following class members are obsolete.</b> "
+              << "They are provided to keep old source code working. "
+              << "We strongly advise against using them in new code.</p>\n";
     }
 
-    out() << "<p><ul><li><a href=\"" << linkForNode(inner, 0) << "\">" << protect(inner->name())
+    out() << "<p><ul><li><a href=\""
+          << linkForNode(inner, 0)
+          << "\">" << protect(inner->name())
           << " class reference</a></li></ul></p>\n";
 
     for (i = 0; i < sections.size(); ++i) {
         out() << "<h3>" << protect(sections.at(i).name) << "</h3>\n";
-
-        generateSectionList(sections.at(i), inner, marker, CodeMarker::Summary);
+        generateSectionList(sections.at(i),inner,marker,CodeMarker::Summary);
     }
 
     sections = marker->sections(inner, CodeMarker::Detailed, status);
@@ -1613,8 +1713,10 @@ QString HtmlGenerator::generateLowStatusMemberFile(const InnerNode *inner, CodeM
     return fileName;
 }
 
-void HtmlGenerator::generateClassHierarchy(const Node *relative, CodeMarker *marker,
-                                           const QMap<QString, const Node *> &classMap)
+void HtmlGenerator::generateClassHierarchy(const Node *relative,
+                                           CodeMarker *marker,
+                                           const QMap<QString,
+                                           const Node *> &classMap)
 {
     if (classMap.isEmpty())
         return;
@@ -1636,8 +1738,10 @@ void HtmlGenerator::generateClassHierarchy(const Node *relative, CodeMarker *mar
         if (stack.top().isEmpty()) {
             stack.pop();
             out() << "</ul>\n";
-        } else {
-            const ClassNode *child = static_cast<const ClassNode *>(*stack.top().begin());
+        }
+        else {
+            const ClassNode *child =
+                static_cast<const ClassNode *>(*stack.top().begin());
             out() << "<li>";
             generateFullName(child, relative, marker);
             out() << "</li>\n";
@@ -1656,8 +1760,9 @@ void HtmlGenerator::generateClassHierarchy(const Node *relative, CodeMarker *mar
     }
 }
 
-void HtmlGenerator::generateAnnotatedList(const Node *relative, CodeMarker *marker,
-                    const QMap<QString, const Node *> &nodeMap)
+void HtmlGenerator::generateAnnotatedList(const Node *relative,
+                                          CodeMarker *marker,
+                                          const QMap<QString, const Node *> &nodeMap)
 {
     out() << "<p><table width=\"100%\" class=\"annotated\" cellpadding=\"2\" cellspacing=\"1\" border=\"0\">\n";
 
@@ -1680,7 +1785,8 @@ void HtmlGenerator::generateAnnotatedList(const Node *relative, CodeMarker *mark
                 generateText(brief, node, marker);
                 out() << "</td>";
             }
-        } else {
+        }
+        else {
             out() << "<td>";
             out() << protect(node->doc().briefText().toString());
             out() << "</td>";
@@ -1690,7 +1796,8 @@ void HtmlGenerator::generateAnnotatedList(const Node *relative, CodeMarker *mark
     out() << "</table></p>\n";
 }
 
-void HtmlGenerator::generateCompactList(const Node *relative, CodeMarker *marker,
+void HtmlGenerator::generateCompactList(const Node *relative,
+                                        CodeMarker *marker,
                                         const QMap<QString, const Node *> &classMap)
 {
     const int NumParagraphs = 37; // '0' to '9', 'A' to 'Z', '_'
@@ -1734,8 +1841,9 @@ void HtmlGenerator::generateCompactList(const Node *relative, CodeMarker *marker
         last = classMap.begin().key();
 
     if (classMap.size() > 1) {
-        while (commonPrefixLen < first.length() + 1 && commonPrefixLen < last.length() + 1
-               && first[commonPrefixLen] == last[commonPrefixLen])
+        while (commonPrefixLen < first.length() + 1 &&
+               commonPrefixLen < last.length() + 1 &&
+               first[commonPrefixLen] == last[commonPrefixLen])
             ++commonPrefixLen;
     }
 
@@ -1764,7 +1872,8 @@ void HtmlGenerator::generateCompactList(const Node *relative, CodeMarker *marker
 
         if (key[0].digitValue() != -1) {
             paragraphNo = key[0].digitValue();
-        } else if (key[0] >= QLatin1Char('a') && key[0] <= QLatin1Char('z')) {
+        }
+        else if (key[0] >= QLatin1Char('a') && key[0] <= QLatin1Char('z')) {
             paragraphNo = 10 + key[0].unicode() - 'a';
         }
 
@@ -1819,7 +1928,8 @@ void HtmlGenerator::generateCompactList(const Node *relative, CodeMarker *marker
             if (currentOffset[i] >= firstOffset[i + 1]) {
                 // this column is finished
                 out() << "<td>\n</td>\n";
-            } else {
+            }
+            else {
                 while (currentOffsetInParagraph[i] == paragraph[currentParagraphNo[i]].count()) {
                     ++currentParagraphNo[i];
                     currentOffsetInParagraph[i] = 0;
@@ -1861,7 +1971,8 @@ void HtmlGenerator::generateCompactList(const Node *relative, CodeMarker *marker
     out() << "</table></p>\n";
 }
 
-void HtmlGenerator::generateFunctionIndex(const Node *relative, CodeMarker *marker)
+void HtmlGenerator::generateFunctionIndex(const Node *relative,
+                                          CodeMarker *marker)
 {
     out() << "<p align=\"center\"><font size=\"+1\"><b>";
     for (int i = 0; i < 26; i++) {
@@ -1910,7 +2021,8 @@ void HtmlGenerator::generateFunctionIndex(const Node *relative, CodeMarker *mark
 #endif
 }
 
-void HtmlGenerator::generateLegaleseList(const Node *relative, CodeMarker *marker)
+void HtmlGenerator::generateLegaleseList(const Node *relative,
+                                         CodeMarker *marker)
 {
     QMap<Text, const Node *>::ConstIterator it = legaleseTexts.begin();
     while (it != legaleseTexts.end()) {
@@ -1928,8 +2040,10 @@ void HtmlGenerator::generateLegaleseList(const Node *relative, CodeMarker *marke
     }
 }
 
-void HtmlGenerator::generateSynopsis(const Node *node, const Node *relative,
-                                     CodeMarker *marker, CodeMarker::SynopsisStyle style)
+void HtmlGenerator::generateSynopsis(const Node *node,
+                                     const Node *relative,
+                                     CodeMarker *marker,
+                                     CodeMarker::SynopsisStyle style)
 {
     QString marked = marker->markedUpSynopsis(node, relative, style);
     QRegExp templateTag("(<[^@>]*>)");
@@ -1939,7 +2053,8 @@ void HtmlGenerator::generateSynopsis(const Node *node, const Node *relative,
         marked.replace(templateTag.pos(1), templateTag.cap(1).length(),
                         contents);
     }
-    marked.replace(QRegExp("<@param>([a-z]+)_([1-9n])</@param>"), "<i>\\1<sub>\\2</sub></i>");
+    marked.replace(QRegExp("<@param>([a-z]+)_([1-9n])</@param>"),
+                   "<i>\\1<sub>\\2</sub></i>");
     marked.replace("<@param>", "<i>");
     marked.replace("</@param>", "</i>");
 
@@ -1950,7 +2065,8 @@ void HtmlGenerator::generateSynopsis(const Node *node, const Node *relative,
         QRegExp extraRegExp("<@extra>.*</@extra>");
         extraRegExp.setMinimal(true);
         marked.replace(extraRegExp, "");
-    } else {
+    }
+    else {
         marked.replace("<@extra>", "&nbsp;&nbsp;<tt>");
         marked.replace("</@extra>", "</tt>");
     }
@@ -1962,7 +2078,41 @@ void HtmlGenerator::generateSynopsis(const Node *node, const Node *relative,
     out() << highlightedCode(marked, marker, relative);
 }
 
-void HtmlGenerator::generateOverviewList(const Node *relative, CodeMarker * /* marker */)
+#ifdef QDOC_QML
+void HtmlGenerator::generateQmlItem(const Node *node,
+                                    const Node *relative,
+                                    CodeMarker *marker,
+                                    bool summary)
+{ 
+    QString marked = marker->markedUpQmlItem(node,summary);
+    QRegExp templateTag("(<[^@>]*>)");
+    if (marked.indexOf(templateTag) != -1) {
+        QString contents = protect(marked.mid(templateTag.pos(1),
+                                              templateTag.cap(1).length()));
+        marked.replace(templateTag.pos(1), templateTag.cap(1).length(),
+                        contents);
+    }
+    marked.replace(QRegExp("<@param>([a-z]+)_([1-9n])</@param>"),
+                   "<i>\\1<sub>\\2</sub></i>");
+    marked.replace("<@param>", "<i>");
+    marked.replace("</@param>", "</i>");
+
+    if (summary)
+        marked.replace("@name>", "b>");
+
+    marked.replace("<@extra>", "&nbsp;&nbsp;<tt>");
+    marked.replace("</@extra>", "</tt>");
+
+    if (summary) {
+        marked.replace("<@type>", "");
+        marked.replace("</@type>", "");
+    }
+    out() << highlightedCode(marked, marker, relative);
+}
+#endif
+
+void HtmlGenerator::generateOverviewList(const Node *relative,
+                                         CodeMarker * /* marker */)
 {
     QMap<const FakeNode *, QMap<QString, FakeNode *> > fakeNodeMap;
     QMap<QString, const FakeNode *> groupTitlesMap;
@@ -1984,7 +2134,7 @@ void HtmlGenerator::generateOverviewList(const Node *relative, CodeMarker * /* m
             }
 
             // there are too many examples; they would clutter the list
-            if (fakeNode->subType() == FakeNode::Example)
+            if (fakeNode->subType() == Node::Example)
                 continue;
 
             // not interested either in individual (Qt Designer etc.) manual chapters
@@ -1992,7 +2142,7 @@ void HtmlGenerator::generateOverviewList(const Node *relative, CodeMarker * /* m
                 continue;
 
             // Discard external nodes.
-            if (fakeNode->subType() == FakeNode::ExternalPage)
+            if (fakeNode->subType() == Node::ExternalPage)
                 continue;
 
             QString sortKey = fakeNode->fullTitle().toLower();
@@ -2017,7 +2167,8 @@ void HtmlGenerator::generateOverviewList(const Node *relative, CodeMarker * /* m
                             groupTitlesMap[fakeNode->fullTitle()] = const_cast<const FakeNode *>(fakeNode);
                         }
                     }
-                } else if (!isGroupPage) {
+                }
+                else if (!isGroupPage) {
                     // If we encounter a page that belongs to a group then
                     // we add that page to the list for that group.
                     const FakeNode *groupNode = static_cast<const FakeNode *>(tre->root()->findNode(group, Node::Fake));
@@ -2075,14 +2226,17 @@ void HtmlGenerator::generateOverviewList(const Node *relative, CodeMarker * /* m
     }
 }
 
-void HtmlGenerator::generateSectionList(const Section& section, const Node *relative,
-                                        CodeMarker *marker, CodeMarker::SynopsisStyle style)
+void HtmlGenerator::generateSectionList(const Section& section,
+                                        const Node *relative,
+                                        CodeMarker *marker,
+                                        CodeMarker::SynopsisStyle style)
 {
     if (!section.members.isEmpty()) {
         bool twoColumn = false;
         if (style == CodeMarker::SeparateList) {
             twoColumn = (section.members.count() >= 16);
-        } else if (section.members.first()->type() == Node::Property) {
+        }
+        else if (section.members.first()->type() == Node::Property) {
             twoColumn = (section.members.count() >= 5);
         }
         if (twoColumn)
@@ -2124,7 +2278,50 @@ void HtmlGenerator::generateSectionList(const Section& section, const Node *rela
     }
 }
 
-void HtmlGenerator::generateSectionInheritedList(const Section& section, const Node *relative,
+#ifdef QDOC_QML
+/*!
+  Generates the summary for for the \a section. Only used for
+  sections of QML element documentation.
+
+  Currently handles only the QML property group.
+ */
+void HtmlGenerator::generateQmlSummary(const Section& section,
+                                       const Node *relative,
+                                       CodeMarker *marker)
+{
+    if (!section.members.isEmpty()) {
+        NodeList::ConstIterator m;
+        int count = section.members.size();
+        bool twoColumn = false;
+        if (section.members.first()->type() == Node::QmlProperty) {
+            twoColumn = (count >= 5);
+        }
+        if (twoColumn)
+            out() << "<p><table width=\"100%\" border=\"0\" cellpadding=\"0\""
+                     " cellspacing=\"0\">\n"
+                  << "<tr><td width=\"45%\" valign=\"top\">";
+        out() << "<ul>\n";
+
+        int row = 0;
+        m = section.members.begin();
+        while (m != section.members.end()) {
+            if (twoColumn && row == (int) (count + 1) / 2)
+                out() << "</ul></td><td valign=\"top\"><ul>\n";
+            out() << "<li><div class=\"fn\"></div>";
+            generateQmlItem(*m,relative,marker,true);
+            out() << "</li>\n";
+            row++;
+            ++m;
+        }
+        out() << "</ul>\n";
+        if (twoColumn)
+            out() << "</td></tr>\n</table></p>\n";
+    }
+}
+#endif
+
+void HtmlGenerator::generateSectionInheritedList(const Section& section,
+                                                 const Node *relative,
                                                  CodeMarker *marker)
 {
     QList<QPair<ClassNode *, int> >::ConstIterator p = section.inherited.begin();
@@ -2133,7 +2330,8 @@ void HtmlGenerator::generateSectionInheritedList(const Section& section, const N
         out() << (*p).second << " ";
         if ((*p).second == 1) {
             out() << section.singularMember;
-        } else {
+        }
+        else {
             out() << section.pluralMember;
         }
         out() << " inherited from <a href=\"" << fileName((*p).first)
@@ -2144,7 +2342,9 @@ void HtmlGenerator::generateSectionInheritedList(const Section& section, const N
     }
 }
 
-void HtmlGenerator::generateLink(const Atom *atom, const Node * /* relative */, CodeMarker *marker)
+void HtmlGenerator::generateLink(const Atom *atom,
+                                 const Node * /* relative */,
+                                 CodeMarker *marker)
 {
     static QRegExp camelCase("[A-Z][A-Z][a-z]|[a-z][A-Z0-9]|_");
 
@@ -2155,12 +2355,14 @@ void HtmlGenerator::generateLink(const Atom *atom, const Node * /* relative */,
         if (link.isEmpty()) {
             if (showBrokenLinks)
                 out() << "</i>";
-        } else {
+        }
+        else {
             out() << "</a>";
         }
         inLink = false;
         out() << protect(atom->string().mid(k));
-    } else if (marker->recognizeLanguage("Java")) {
+    }
+    else if (marker->recognizeLanguage("Java")) {
 	// hack for Java: remove () and use <tt> when appropriate
         bool func = atom->string().endsWith("()");
         bool tt = (func || atom->string().contains(camelCase));
@@ -2168,11 +2370,13 @@ void HtmlGenerator::generateLink(const Atom *atom, const Node * /* relative */,
             out() << "<tt>";
         if (func) {
             out() << protect(atom->string().left(atom->string().length() - 2));
-        } else {
+        }
+        else {
             out() << protect(atom->string());
         }
         out() << "</tt>";
-    } else {
+    }
+    else {
         out() << protect(atom->string());
     }
 }
@@ -2192,11 +2396,14 @@ QString HtmlGenerator::cleanRef(const QString& ref)
          (u >= 'A' && u <= 'Z') ||
          (u >= '0' && u <= '9')) {
         clean += c;
-    } else if (u == '~') {
+    }
+    else if (u == '~') {
         clean += "dtor.";
-    } else if (u == '_') {
+    }
+    else if (u == '_') {
         clean += "underscore.";
-    } else {
+    }
+    else {
         clean += "A";
     }
 
@@ -2208,21 +2415,29 @@ QString HtmlGenerator::cleanRef(const QString& ref)
              (u >= '0' && u <= '9') || u == '-' ||
              u == '_' || u == ':' || u == '.') {
             clean += c;
-        } else if (c.isSpace()) {
+        }
+        else if (c.isSpace()) {
             clean += "-";
-        } else if (u == '!') {
+        }
+        else if (u == '!') {
             clean += "-not";
-        } else if (u == '&') {
+        }
+        else if (u == '&') {
             clean += "-and";
-        } else if (u == '<') {
+        }
+        else if (u == '<') {
             clean += "-lt";
-        } else if (u == '=') {
+        }
+        else if (u == '=') {
             clean += "-eq";
-        } else if (u == '>') {
+        }
+        else if (u == '>') {
             clean += "-gt";
-        } else if (u == '#') {
+        }
+        else if (u == '#') {
             clean += "#";
-        } else {
+        }
+        else {
             clean += "-";
             clean += QString::number((int)u, 16);
         }
@@ -2239,7 +2454,8 @@ QString HtmlGenerator::registerRef(const QString& ref)
         if (prevRef.isEmpty()) {
             prevRef = ref;
             break;
-        } else if (prevRef == ref) {
+        }
+        else if (prevRef == ref) {
             break;
         }
         clean += "x";
@@ -2264,20 +2480,29 @@ QString HtmlGenerator::protect(const QString& string)
 
         if (ch == QLatin1Char('&')) {
             APPEND("&amp;");
-        } else if (ch == QLatin1Char('<')) {
+        }
+        else if (ch == QLatin1Char('<')) {
             APPEND("&lt;");
-        } else if (ch == QLatin1Char('>')) {
+        }
+        else if (ch == QLatin1Char('>')) {
             APPEND("&gt;");
-        } else if (ch == QLatin1Char('"')) {
+        }
+        else if (ch == QLatin1Char('"')) {
             APPEND("&quot;");
-        } else if (ch.unicode() > 0x007F
-                   || (ch == QLatin1Char('*') && i + 1 < n && string.at(i) == QLatin1Char('/'))
-                   || (ch == QLatin1Char('.') && i > 2 && string.at(i - 2) == QLatin1Char('.'))) {
+        }
+        else if (ch.unicode() > 0x007F ||
+                 (ch == QLatin1Char('*') &&
+                  i + 1 < n &&
+                  string.at(i) == QLatin1Char('/')) ||
+                 (ch == QLatin1Char('.') &&
+                  i > 2 &&
+                  string.at(i - 2) == QLatin1Char('.'))) {
             // we escape '*/' and the last dot in 'e.g.' and 'i.e.' for the Javadoc generator
             APPEND("&#x");
             html += QString::number(ch.unicode(), 16);
             html += QLatin1Char(';');
-        } else {
+        }
+        else {
             if (!html.isEmpty())
                 html += ch;
         }
@@ -2357,7 +2582,8 @@ bool parseArg(const QString &src,
             *par1 = QStringRef(&src, j, i - j);
             SKIP_CHAR('"');
             SKIP_SPACE;
-        } else {
+        }
+        else {
             if (debug)
                 qDebug() << "no optional parameter found";
         }
@@ -2428,8 +2654,8 @@ QString HtmlGenerator::highlightedCode(const QString& markedCode,
         if (src.at(i) == charLangle && src.at(i + 1) == charAt) {
             i += 2;
             if (parseArg(src, linkTag, &i, n, &arg, &par1)) {
-                QString link = linkForNode(
-                    CodeMarker::nodeForString(par1.toString()), relative);
+                const Node* node = CodeMarker::nodeForString(par1.toString());
+                QString link = linkForNode(node, relative);
                 addLink(link, arg, &html);
             }
             else {
@@ -2442,7 +2668,6 @@ QString HtmlGenerator::highlightedCode(const QString& markedCode,
         }
     }
 
-
     if (slow) {
         // is this block ever used at all?
         // replace all <@func> tags: "(<@func target=\"([^\"]*)\">)(.*)(</@func>)"
@@ -2618,10 +2843,9 @@ QString HtmlGenerator::fileBase(const Node *node,
 QString HtmlGenerator::fileName(const Node *node)
 {
     if (node->type() == Node::Fake) {
-        if (static_cast<const FakeNode *>(node)->subType() == FakeNode::ExternalPage)
+        if (static_cast<const FakeNode *>(node)->subType() == Node::ExternalPage)
             return node->name();
     }
-
     return PageGenerator::fileName(node);
 }
 
@@ -2643,7 +2867,8 @@ QString HtmlGenerator::refForNode(const Node *node)
         typedeffe = static_cast<const TypedefNode *>(node);
         if (typedeffe->associatedEnum()) {
             return refForNode(typedeffe->associatedEnum());
-        } else {
+        }
+        else {
             ref = node->name() + "-typedef";
         }
         break;
@@ -2651,15 +2876,27 @@ QString HtmlGenerator::refForNode(const Node *node)
         func = static_cast<const FunctionNode *>(node);
         if (func->associatedProperty()) {
             return refForNode(func->associatedProperty());
-        } else {
+        }
+        else {
             ref = func->name();
             if (func->overloadNumber() != 1)
                 ref += "-" + QString::number(func->overloadNumber());
         }
         break;
     case Node::Property:
+#ifdef QDOC_QML        
+    case Node::QmlProperty:
+#endif        
         ref = node->name() + "-prop";
         break;
+#ifdef QDOC_QML        
+    case Node::QmlSignal:
+        ref = node->name() + "-signal";
+        break;
+    case Node::QmlMethod:
+        ref = node->name() + "-method";
+        break;
+#endif        
     case Node::Variable:
         ref = node->name() + "-var";
         break;
@@ -2708,9 +2945,11 @@ QString HtmlGenerator::refForAtom(Atom *atom, const Node * /* node */)
 {
     if (atom->type() == Atom::SectionLeft) {
         return Doc::canonicalTitle(Text::sectionHeading(atom).toString());
-    } else if (atom->type() == Atom::Target) {
+    }
+    else if (atom->type() == Atom::Target) {
         return Doc::canonicalTitle(atom->string());
-    } else {
+    }
+    else {
         return QString();
     }
 }
@@ -2754,7 +2993,10 @@ void HtmlGenerator::generateDetailedMember(const Node *node,
         out() << "<a name=\"" + refForNode(node) + "\"></a>";
         generateSynopsis(enume, relative, marker, CodeMarker::Detailed);
         out() << "<br />";
-        generateSynopsis(enume->flagsType(), relative, marker, CodeMarker::Detailed);
+        generateSynopsis(enume->flagsType(),
+                         relative,
+                         marker,
+                         CodeMarker::Detailed);
         out() << "</h3>\n";
     }
     else {
@@ -2789,7 +3031,8 @@ void HtmlGenerator::generateDetailedMember(const Node *node,
                   << " type is a typedef for "
                   << "<a href=\"qflags.html\">QFlags</a>&lt;"
                   << protect(enume->name())
-                  << "&gt;. It stores an OR combination of " << protect(enume->name())
+                  << "&gt;. It stores an OR combination of "
+                  << protect(enume->name())
                   << " values.</p>\n";
         }
     }
@@ -2901,7 +3144,7 @@ void HtmlGenerator::findAllNamespaces(const InnerNode *node)
     }
 }
 
-#ifdef ZZZ_QDOC_QML    
+#ifdef ZZZ_QDOC_QML
 /*!
   This function finds all the qml element nodes and
   stores them in a map for later use.
@@ -2912,24 +3155,16 @@ void HtmlGenerator::findAllQmlClasses(const InnerNode *node)
     while (c != node->childNodes().constEnd()) {
         if ((*c)->type() == Node::Fake) {
             const FakeNode* fakeNode = static_cast<const FakeNode *>(*c);
-            if (fakeNode->subType() == FakeNode::QmlClass) {
-                const QmlNode* qmlNode = static_cast<const QmlNode*>(fakeNode);
-                //qDebug() << "HtmlGenerator: QML CLASS" << qmlNode->name();
+            if (fakeNode->subType() == Node::QmlClass) {
+                const QmlClassNode* qmlNode =
+                    static_cast<const QmlClassNode*>(fakeNode);
                 const Node* n = qmlNode->classNode();
-                if (n)
-                    //qDebug() << "  FOUND IT!" << n->name();
             }
             qmlClasses.insert(fakeNode->name(),*c);
         }
         ++c;
     }
 }
-#endif    
-
-#if 0
-            else if ((*c)->isInnerNode()) {
-                findAllClasses(static_cast<InnerNode *>(*c));
-            }
 #endif
 
 int HtmlGenerator::hOffset(const Node *node)
@@ -3193,3 +3428,165 @@ void HtmlGenerator::endLink()
 }
 
 QT_END_NAMESPACE
+
+#ifdef QDOC_QML
+
+/*!
+  Outputs the html detailed documentation for a section
+  on a QML element reference page.
+ */
+void HtmlGenerator::generateDetailedQmlMember(const Node *node,
+                                              const InnerNode *relative,
+                                              CodeMarker *marker)
+{
+    const QmlPropertyNode* qpn = 0;
+    generateMacRef(node, marker);
+    out() << "<div class=\"qmlitem\">";
+    if (node->subType() == Node::QmlPropertyGroup) {
+        const QmlPropGroupNode* qpgn = static_cast<const QmlPropGroupNode*>(node);
+        NodeList::ConstIterator p = qpgn->childNodes().begin();
+        out() << "<div class=\"qmlproto\">";
+        out() << "<table class=\"qmlname\">";
+
+        while (p != qpgn->childNodes().end()) {
+            if ((*p)->type() == Node::QmlProperty) {
+                qpn = static_cast<const QmlPropertyNode*>(*p);
+                out() << "<tr><td>";
+                out() << "<a name=\"" + refForNode(qpn) + "\"></a>";
+                generateQmlItem(qpn, relative, marker, false);
+                out() << "</td></tr>";
+            }
+            ++p;
+        }
+        out() << "</table>";
+        out() << "</div>";
+    }
+    else if (node->type() == Node::QmlSignal) {
+        const QmlSignalNode* qsn = static_cast<const QmlSignalNode*>(node);
+        out() << "<div class=\"qmlproto\">";
+        out() << "<table class=\"qmlname\">";
+        out() << "<tr><td>";
+        out() << "<a name=\"" + refForNode(qsn) + "\"></a>";
+        generateQmlItem(qsn,relative,marker,false);
+        out() << "</td></tr>";
+        out() << "</table>";
+        out() << "</div>";
+    }
+    else if (node->type() == Node::QmlMethod) {
+        const QmlMethodNode* qmn = static_cast<const QmlMethodNode*>(node);
+        out() << "<div class=\"qmlproto\">";
+        out() << "<table class=\"qmlname\">";
+        out() << "<tr><td>";
+        out() << "<a name=\"" + refForNode(qmn) + "\"></a>";
+        generateQmlItem(qmn,relative,marker,false);
+        out() << "</td></tr>";
+        out() << "</table>";
+        out() << "</div>";
+    }
+    out() << "<div class=\"qmldoc\">";
+    generateStatus(node, marker);
+    generateBody(node, marker);
+    generateThreadSafeness(node, marker);
+    generateSince(node, marker);
+    generateAlsoList(node, marker);
+    out() << "</div>";
+    out() << "</div>";
+}
+
+/*!
+  Output the "Inherits" line for the QML element,
+  if there should be one.
+ */
+void HtmlGenerator::generateQmlInherits(const QmlClassNode* cn,
+                                        CodeMarker* marker)
+{
+    if (cn && !cn->links().empty()) {
+        if (cn->links().contains(Node::InheritsLink)) {
+            QPair<QString,QString> linkPair;
+            linkPair = cn->links()[Node::InheritsLink];
+            QStringList strList(linkPair.first);
+            const Node* n = tre->findNode(strList,Node::Fake);
+            if (n && n->subType() == Node::QmlClass) {
+                const QmlClassNode* qcn = static_cast<const QmlClassNode*>(n);
+                out() << "<p style=\"text-align: center\">";
+                Text text;
+                text << "[Inherits ";
+                text << Atom(Atom::LinkNode,CodeMarker::stringForNode(qcn));
+                text << Atom(Atom::FormattingLeft, ATOM_FORMATTING_LINK);
+                text << Atom(Atom::String, linkPair.second);
+                text << Atom(Atom::FormattingRight, ATOM_FORMATTING_LINK);
+                text << "]";
+                generateText(text, cn, marker);
+                out() << "</p>";
+            }
+            else
+                qDebug() << "generateQmlInherits(): "
+                         << "Inherited element not documented -->"
+                         << linkPair.first;
+        }
+    }
+}
+
+/*!
+  Output the "[Xxx instantiates the C++ class QFxXxx]"
+  line for the QML element, if there should be one.
+
+  If there is no class node, or if the class node status
+  is set to Node::Internal, do nothing. 
+ */
+void HtmlGenerator::generateQmlInstantiates(const QmlClassNode* qcn,
+                                            CodeMarker* marker)
+{
+    const ClassNode* cn = qcn->classNode();
+    if (cn && (cn->status() != Node::Internal)) {
+        out() << "<p style=\"text-align: center\">";
+        Text text;
+        text << "[";
+        text << Atom(Atom::LinkNode,CodeMarker::stringForNode(qcn));
+        text << Atom(Atom::FormattingLeft, ATOM_FORMATTING_LINK);
+        text << Atom(Atom::String, qcn->name());
+        text << Atom(Atom::FormattingRight, ATOM_FORMATTING_LINK);
+        text << " instantiates the C++ class ";
+        text << Atom(Atom::LinkNode,CodeMarker::stringForNode(cn));
+        text << Atom(Atom::FormattingLeft, ATOM_FORMATTING_LINK);
+        text << Atom(Atom::String, cn->name());
+        text << Atom(Atom::FormattingRight, ATOM_FORMATTING_LINK);
+        text << "]";
+        generateText(text, qcn, marker);
+        out() << "</p>";
+    }
+}
+
+/*!
+  Output the "[QFxXxx is instantiated by QML element Xxx]"
+  line for the class, if there should be one.
+
+  If there is no QML element, or if the class node status
+  is set to Node::Internal, do nothing. 
+ */
+void HtmlGenerator::generateInstantiatedBy(const ClassNode* cn,
+                                           CodeMarker* marker)
+{
+    if (cn &&  cn->status() != Node::Internal && !cn->qmlElement().isEmpty()) {
+        const Node* n = tre->root()->findNode(cn->qmlElement(),Node::Fake);
+        if (n && n->subType() == Node::QmlClass) {
+            out() << "<p style=\"text-align: center\">";
+            Text text;
+            text << "[";
+            text << Atom(Atom::LinkNode,CodeMarker::stringForNode(cn));
+            text << Atom(Atom::FormattingLeft, ATOM_FORMATTING_LINK);
+            text << Atom(Atom::String, cn->name());
+            text << Atom(Atom::FormattingRight, ATOM_FORMATTING_LINK);
+            text << " is instantiated by QML element ";
+            text << Atom(Atom::LinkNode,CodeMarker::stringForNode(n));
+            text << Atom(Atom::FormattingLeft, ATOM_FORMATTING_LINK);
+            text << Atom(Atom::String, n->name());
+            text << Atom(Atom::FormattingRight, ATOM_FORMATTING_LINK);
+            text << "]";
+            generateText(text, cn, marker);
+            out() << "</p>";
+        }
+    }
+}
+
+#endif
diff --git a/tools/qdoc3/htmlgenerator.h b/tools/qdoc3/htmlgenerator.h
index de64190..ba484f3 100644
--- a/tools/qdoc3/htmlgenerator.h
+++ b/tools/qdoc3/htmlgenerator.h
@@ -147,19 +147,40 @@ class HtmlGenerator : public PageGenerator
                              const Node *relative,
 			     CodeMarker *marker, 
                              CodeMarker::SynopsisStyle style);
-    void generateSectionInheritedList(const Section& section, 
+#ifdef QDOC_QML
+    void generateQmlSummary(const Section& section,
+                            const Node *relative,
+                            CodeMarker *marker);
+    void generateQmlItem(const Node *node,
+                         const Node *relative,
+                         CodeMarker *marker,
+                         bool summary);
+    void generateDetailedQmlMember(const Node *node,
+                                   const InnerNode *relative,
+                                   CodeMarker *marker);
+    void generateQmlInherits(const QmlClassNode* cn, CodeMarker* marker);
+    void generateQmlInstantiates(const QmlClassNode* qcn, CodeMarker* marker);
+    void generateInstantiatedBy(const ClassNode* cn, CodeMarker* marker);
+#endif
+   void generateSectionInheritedList(const Section& section, 
                                       const Node *relative,
                                       CodeMarker *marker);
     void generateFullName(const Node *apparentNode, 
                           const Node *relative, 
                           CodeMarker *marker,
 			  const Node *actualNode = 0);
-    void generateDetailedMember(const Node *node, const InnerNode *relative, CodeMarker *marker);
-    void generateLink(const Atom *atom, const Node *relative, CodeMarker *marker);
+    void generateDetailedMember(const Node *node, 
+                                const InnerNode *relative, 
+                                CodeMarker *marker);
+    void generateLink(const Atom *atom, 
+                      const Node *relative, 
+                      CodeMarker *marker);
     void generateStatus(const Node *node, CodeMarker *marker);
     
     QString registerRef(const QString& ref);
-    QString highlightedCode(const QString& markedCode, CodeMarker *marker, const Node *relative);
+    QString highlightedCode(const QString& markedCode, 
+                            CodeMarker *marker, 
+                            const Node *relative);
     QString fileBase(const Node *node);
 #if 0
     QString fileBase(const Node *node, const SectionIterator& section);
diff --git a/tools/qdoc3/jambiapiparser.cpp b/tools/qdoc3/jambiapiparser.cpp
index 73d10a6..05c7be8 100644
--- a/tools/qdoc3/jambiapiparser.cpp
+++ b/tools/qdoc3/jambiapiparser.cpp
@@ -234,8 +234,9 @@ void JambiApiParser::doneParsingSourceFiles(Tree * /* tree */)
     foreach (Node *cppNode, cppTre->root()->childNodes()) {
         if (cppNode->type() == Node::Fake) {
             FakeNode *cppFake = static_cast<FakeNode *>(cppNode);
-            if (cppFake->subType() == FakeNode::Page) {
-                FakeNode *javaFake = new FakeNode(javaTre->root(), cppFake->name(),
+            if (cppFake->subType() == Node::Page) {
+                FakeNode *javaFake = new FakeNode(javaTre->root(),
+                                                  cppFake->name(),
                                                   cppFake->subType());
                 javaFake->setModuleName("com.trolltech.qt");    // ### hard-coded
                 javaFake->setTitle(cppFake->title());
diff --git a/tools/qdoc3/node.cpp b/tools/qdoc3/node.cpp
index 231149e..211e2df 100644
--- a/tools/qdoc3/node.cpp
+++ b/tools/qdoc3/node.cpp
@@ -43,6 +43,7 @@
   node.cpp
 */
 
+#include <QtCore>
 #include "node.h"
 
 QT_BEGIN_NAMESPACE
@@ -113,6 +114,9 @@ void Node::setRelates(InnerNode *pseudoParent)
 }
 
 /*!
+  This function creates a pair that describes a link.
+  The pair is composed from \a link and \a desc. The
+  \a linkType is the map index the pair is filed under.
  */
 void Node::setLink(LinkType linkType, const QString &link, const QString &desc)
 {
@@ -623,7 +627,7 @@ void InnerNode::removeRelated(Node *pseudoChild)
  */
 
 /*!
-  Returns false because this is an InnerNode.
+  Returns false because this is a LeafNode.
  */
 bool LeafNode::isInnerNode() const
 {
@@ -713,9 +717,11 @@ void ClassNode::fixBaseClasses()
  */
 
 /*!
+  The type of a FakeNode is Fake, and it has a \a subtype,
+  which specifies the type of FakeNode.
  */
-FakeNode::FakeNode(InnerNode *parent, const QString& name, SubType subType)
-    : InnerNode(Fake, parent, name), sub(subType)
+FakeNode::FakeNode(InnerNode *parent, const QString& name, SubType subtype)
+    : InnerNode(Fake, parent, name), sub(subtype)
 {
 }
 
@@ -1021,4 +1027,98 @@ bool TargetNode::isInnerNode() const
     return false;
 }
 
+#ifdef QDOC_QML
+/*!
+  Constructor for the Qml class node.
+ */
+QmlClassNode::QmlClassNode(InnerNode *parent,
+                           const QString& name,
+                           const ClassNode* cn)
+    : FakeNode(parent, name, QmlClass), cnode(cn)
+{
+    setTitle("QML " + name + " Element Reference");
+}
+
+/*!
+  The base file name for this kind of node has "qml"
+  prepended to it.
+
+  But not yet. Still testing.
+ */
+QString QmlClassNode::fileBase() const
+{
+#if 0    
+    if (Node::fileBase() == "item")
+        qDebug() << "FILEBASE: qmlitem" << name();
+    return "qml" + Node::fileBase();
+#endif
+    return Node::fileBase();
+}
+
+/*!
+  Constructor for the Qml property group node. \a parent is
+  always a QmlClassNode. 
+ */
+QmlPropGroupNode::QmlPropGroupNode(QmlClassNode* parent, const QString& name)
+    : FakeNode(parent, name, QmlPropertyGroup)
+{
+    // nothing.
+}
+
+/*!
+  Constructor for the QML property node.
+ */
+QmlPropertyNode::QmlPropertyNode(QmlPropGroupNode *parent,
+                                 const QString& name,
+                                 const QString& type)
+    : LeafNode(QmlProperty, parent, name),
+      dt(type),
+      sto(Trool_Default),
+      des(Trool_Default)
+{
+    // nothing.
+}
+
+/*!
+  I don't know what this is.
+ */
+QmlPropertyNode::Trool QmlPropertyNode::toTrool(bool boolean)
+{
+    return boolean ? Trool_True : Trool_False;
+}
+
+/*!
+  I don't know what this is either.
+ */
+bool QmlPropertyNode::fromTrool(Trool troolean, bool defaultValue)
+{
+    switch (troolean) {
+    case Trool_True:
+        return true;
+    case Trool_False:
+        return false;
+    default:
+        return defaultValue;
+    }
+}
+
+/*!
+  Constructor for the QML signal node.
+ */
+QmlSignalNode::QmlSignalNode(QmlClassNode *parent, const QString& name)
+    : LeafNode(QmlSignal, parent, name)
+{
+    // nothing.
+}
+
+/*!
+  Constructor for the QML method node.
+ */
+QmlMethodNode::QmlMethodNode(QmlClassNode *parent, const QString& name)
+    : LeafNode(QmlMethod, parent, name)
+{
+    // nothing.
+}
+#endif
+
 QT_END_NAMESPACE
diff --git a/tools/qdoc3/node.h b/tools/qdoc3/node.h
index c34b82b..477c2d2 100644
--- a/tools/qdoc3/node.h
+++ b/tools/qdoc3/node.h
@@ -72,7 +72,31 @@ class Node
         Function, 
         Property,
         Variable, 
+#ifdef QDOC_QML
+        Target,
+        QmlProperty,
+        QmlSignal,
+        QmlMethod
+#else
         Target 
+#endif
+    };
+
+    enum SubType { 
+        NoSubType,
+        Example, 
+        HeaderFile, 
+        File,
+        Group,
+        Module,
+        Page,
+#ifdef QDOC_QML
+        ExternalPage,
+        QmlClass,
+        QmlPropertyGroup
+#else
+        ExternalPage
+#endif
     };
     
     enum Access { Public, Protected, Private };
@@ -99,7 +123,8 @@ class Node
         NextLink, 
         PreviousLink,
         ContentsLink, 
-        IndexLink /*, 
+        IndexLink,
+        InheritsLink /*, 
         GlossaryLink, 
         CopyrightLink,
         ChapterLink, 
@@ -124,6 +149,7 @@ class Node
 
     virtual bool isInnerNode() const = 0;
     Type type() const { return typ; }
+    virtual SubType subType() const { return NoSubType; }
     InnerNode *parent() const { return par; }
     InnerNode *relates() const { return rel; }
     const QString& name() const { return nam; }
@@ -143,7 +169,7 @@ class Node
 
     void clearRelated() { rel = 0; }
 
-    QString fileBase() const;
+    virtual QString fileBase() const;
 
  protected:
     Node(Type type, InnerNode *parent, const QString& name);
@@ -180,7 +206,7 @@ typedef QList<Node *> NodeList;
 class InnerNode : public Node
 {
  public:
-    ~InnerNode();
+    virtual ~InnerNode();
 
     Node *findNode(const QString& name);
     Node *findNode(const QString& name, Type type);
@@ -202,6 +228,7 @@ class InnerNode : public Node
     const EnumNode *findEnumNodeForValue(const QString &enumValue) const;
     const NodeList & childNodes() const { return children; }
     const NodeList & relatedNodes() const { return related; }
+    int count() const { return children.size(); }
     int overloadNumber(const FunctionNode *func) const;
     int numOverloads(const QString& funcName) const;
     NodeList overloads(const QString &funcName) const;
@@ -231,17 +258,19 @@ class LeafNode : public Node
 {
  public:
     LeafNode();
+    virtual ~LeafNode() { }
 
     virtual bool isInnerNode() const;
 
  protected:
-    LeafNode(Type type, InnerNode *parent, const QString& name);
+    LeafNode(Type type, InnerNode* parent, const QString& name);
 };
 
 class NamespaceNode : public InnerNode
 {
  public:
     NamespaceNode(InnerNode *parent, const QString& name);
+    virtual ~NamespaceNode() { }
 };
 
 class ClassNode;
@@ -265,6 +294,7 @@ class ClassNode : public InnerNode
 {
  public:
     ClassNode(InnerNode *parent, const QString& name);
+    virtual ~ClassNode() { }
 
     void addBaseClass(Access access, 
                       ClassNode *node, 
@@ -279,29 +309,23 @@ class ClassNode : public InnerNode
 
     QString serviceName() const { return sname; }
     void setServiceName(const QString& value) { sname = value; }
+    QString qmlElement() const { return qmlelement; }
+    void setQmlElement(const QString& value) { qmlelement = value; }
 
  private:
     QList<RelatedClass> bas;
     QList<RelatedClass> der;
     bool hidden;
     QString sname;
+    QString qmlelement;
 };
 
 class FakeNode : public InnerNode
 {
  public:
-    enum SubType { 
-        Example, 
-        HeaderFile, 
-        File,
-        Group,
-        Module,
-        Page,
-        ExternalPage,
-        QmlClass
-    };
 
     FakeNode(InnerNode *parent, const QString& name, SubType subType);
+    virtual ~FakeNode() { }
 
     void setTitle(const QString &title) { tle = title; }
     void setSubTitle(const QString &subTitle) { stle = subTitle; }
@@ -320,18 +344,80 @@ class FakeNode : public InnerNode
     NodeList gr;
 };
 
-class QmlNode : public FakeNode
+#ifdef QDOC_QML
+class QmlClassNode : public FakeNode
 {
  public:
-    QmlNode(InnerNode *parent, const QString& name, const ClassNode* cn)
-        : FakeNode(parent, name, QmlClass), cnode(cn) { }
+    QmlClassNode(InnerNode *parent, 
+                 const QString& name, 
+                 const ClassNode* cn);
+    virtual ~QmlClassNode() { }
 
     const ClassNode* classNode() const { return cnode; }
+    virtual QString fileBase() const;
 
  private:
     const ClassNode* cnode;
 };
 
+class QmlPropGroupNode : public FakeNode
+{
+ public:
+    QmlPropGroupNode(QmlClassNode* parent, const QString& name);
+    virtual ~QmlPropGroupNode() { }
+
+    const QString& element() const { return name(); }
+};
+
+class QmlPropertyNode : public LeafNode
+{
+ public:
+    QmlPropertyNode(QmlPropGroupNode* parent, 
+                    const QString& name,
+                    const QString& type);
+    virtual ~QmlPropertyNode() { }
+
+    void setDataType(const QString& dataType) { dt = dataType; }
+    void setStored(bool stored) { sto = toTrool(stored); }
+    void setDesignable(bool designable) { des = toTrool(designable); }
+
+    const QString &dataType() const { return dt; }
+    QString qualifiedDataType() const { return dt; }
+    bool isStored() const { return fromTrool(sto,true); }
+    bool isDesignable() const { return fromTrool(des,false); }
+
+    const QString& element() const { return parent()->name(); }
+
+ private:
+    enum Trool { Trool_True, Trool_False, Trool_Default };
+
+    static Trool toTrool(bool boolean);
+    static bool fromTrool(Trool troolean, bool defaultValue);
+
+    QString dt;
+    Trool sto;
+    Trool des;
+};
+
+class QmlSignalNode : public LeafNode
+{
+ public:
+    QmlSignalNode(QmlClassNode* parent, const QString& name);
+    virtual ~QmlSignalNode() { }
+
+    const QString& element() const { return parent()->name(); }
+};
+
+class QmlMethodNode : public LeafNode
+{
+ public:
+    QmlMethodNode(QmlClassNode* parent, const QString& name);
+    virtual ~QmlMethodNode() { }
+
+    const QString& element() const { return parent()->name(); }
+};
+#endif
+
 class EnumItem
 {
  public:
@@ -357,6 +443,7 @@ class EnumNode : public LeafNode
 {
  public:
     EnumNode(InnerNode *parent, const QString& name);
+    virtual ~EnumNode() { }
 
     void addItem(const EnumItem& item);
     void setFlagsType(TypedefNode *typedeff);
@@ -377,6 +464,7 @@ class TypedefNode : public LeafNode
 {
  public:
     TypedefNode(InnerNode *parent, const QString& name);
+    virtual ~TypedefNode() { }
 
     const EnumNode *associatedEnum() const { return ae; }
 
@@ -437,6 +525,7 @@ class FunctionNode : public LeafNode
     enum Virtualness { NonVirtual, ImpureVirtual, PureVirtual };
 
     FunctionNode(InnerNode *parent, const QString &name);
+    virtual ~FunctionNode() { }
 
     void setReturnType(const QString& returnType) { rt = returnType; }
     void setMetaness(Metaness metaness) { met = metaness; }
@@ -496,6 +585,7 @@ class PropertyNode : public LeafNode
     enum { NumFunctionRoles = Resetter + 1 };
 
     PropertyNode(InnerNode *parent, const QString& name);
+    virtual ~PropertyNode() { }
 
     void setDataType(const QString& dataType) { dt = dataType; }
     void addFunction(FunctionNode *function, FunctionRole role);
@@ -553,6 +643,7 @@ class VariableNode : public LeafNode
 {
  public:
     VariableNode(InnerNode *parent, const QString &name);
+    virtual ~VariableNode() { }
 
     void setLeftType(const QString &leftType) { lt = leftType; }
     void setRightType(const QString &rightType) { rt = rightType; }
@@ -578,6 +669,7 @@ class TargetNode : public LeafNode
 {
  public:
     TargetNode(InnerNode *parent, const QString& name);
+    virtual ~TargetNode() { }
 
     virtual bool isInnerNode() const;
 };
diff --git a/tools/qdoc3/pagegenerator.cpp b/tools/qdoc3/pagegenerator.cpp
index 2d50279..8504d2d 100644
--- a/tools/qdoc3/pagegenerator.cpp
+++ b/tools/qdoc3/pagegenerator.cpp
@@ -81,30 +81,50 @@ QString PageGenerator::fileBase(const Node *node)
 {
     if (node->relates())
 	node = node->relates();
-    else if (!node->isInnerNode())
+    else if (!node->isInnerNode()) {
 	node = node->parent();
+#ifdef QDOC_QML
+        if (node->subType() == Node::QmlPropertyGroup) {
+            node = node->parent();
+        }
+#endif        
+    }
 
     QString base = node->doc().baseName();
     if (!base.isEmpty())
         return base;
 
-	const Node *p = node;
-
-        forever {
-            base.prepend(p->name());
+    const Node *p = node;
+
+    forever {
+        base.prepend(p->name());
+#ifdef QDOC_QML
+        /*
+          To avoid file name conflicts in the html directory,
+          we prepend "qml" to the file name of QML element doc
+          files.
+         */
+        if ((p->subType() == Node::QmlClass) ||
+            (p->subType() == Node::QmlPropertyGroup))
+            base.prepend("qml");
+        else if ((p->type() == Node::QmlProperty) ||
+                 (p->type() == Node::QmlSignal) ||
+                 (p->type() == Node::QmlMethod))
+            base.prepend("qml");
+#endif        
         const Node *pp = p->parent();
         if (!pp || pp->name().isEmpty() || pp->type() == Node::Fake)
-                break;
+            break;
         base.prepend(QLatin1Char('-'));
         p = pp;
-        }
-
-        if (node->type() == Node::Fake) {
+    }
+    
+    if (node->type() == Node::Fake) {
 #ifdef QDOC2_COMPAT
-            if (base.endsWith(".html"))
-	        base.truncate(base.length() - 5);
+        if (base.endsWith(".html"))
+            base.truncate(base.length() - 5);
 #endif
-        }
+    }
 
     // the code below is effectively equivalent to:
     //   base.replace(QRegExp("[^A-Za-z0-9]+"), " ");
@@ -126,7 +146,8 @@ QString PageGenerator::fileBase(const Node *node)
         if ((u >= 'a' &&  u <= 'z') || (u >= '0' && u <= '9')) {
             res += QLatin1Char(u);
             begun = true;
-        } else if (begun) {
+        }
+        else if (begun) {
             res += QLatin1Char('-');
             begun = false;
         }
@@ -187,8 +208,12 @@ void PageGenerator::generateInnerNode(const InnerNode *node,
 
     if (node->type() == Node::Fake) {
         const FakeNode *fakeNode = static_cast<const FakeNode *>(node);
-        if (fakeNode->subType() == FakeNode::ExternalPage)
+        if (fakeNode->subType() == Node::ExternalPage)
+            return;
+#ifdef QDOC_QML            
+        if (fakeNode->subType() == Node::QmlPropertyGroup)
             return;
+#endif            
     }
 
     if (node->parent() != 0) {
@@ -197,12 +222,6 @@ void PageGenerator::generateInnerNode(const InnerNode *node,
 	    generateClassLikeNode(node, marker);
 	}
         else if (node->type() == Node::Fake) {
-            const FakeNode* fakeNode = static_cast<const FakeNode *>(node);
-#ifdef QDOC_QML            
-            if (fakeNode->subType() == FakeNode::QmlClass) {
-                //qDebug() << "FILENAME:" << fileName(node);
-            }
-#endif            
 	    generateFakeNode(static_cast<const FakeNode *>(node), marker);
 	}
 	endSubPage();
diff --git a/tools/qdoc3/test/classic.css b/tools/qdoc3/test/classic.css
index 6cf7377..92a90d4 100644
--- a/tools/qdoc3/test/classic.css
+++ b/tools/qdoc3/test/classic.css
@@ -137,3 +137,45 @@ span.string,span.char
 {
     font-size: 0.65em
 }
+
+.qmlitem {
+	padding: 0;
+}
+
+.qmlname {
+	white-space: nowrap;
+	font-weight: bold;
+}
+
+.qmlproto, .qmldoc {
+	border: 1px solid #84b0c7;	
+}
+
+.qmlproto {
+	padding: 0;
+	background-color: #d5e1e8;
+	font-weight: bold;
+	-webkit-border-top-left-radius: 8px;
+	-webkit-border-top-right-radius: 8px;
+	-moz-border-radius-topleft: 8px;
+	-moz-border-radius-topright: 8px;
+}
+
+.qmldoc {
+	padding: 2px 5px;
+	background-color: #eef3f5;
+	border-top-width: 0;
+	-webkit-border-bottom-left-radius: 8px;
+	-webkit-border-bottom-right-radius: 8px;
+	-moz-border-radius-bottomleft: 8px;
+	-moz-border-radius-bottomright: 8px;
+}
+
+.qmldoc p, .qmldoc dl, .qmldoc ul {
+	margin: 6px 0;
+}
+
+*.qmlitem p {
+        margin-top: 0px;
+        margin-bottom: 0px;
+}
diff --git a/tools/qdoc3/test/qt-build-docs.qdocconf b/tools/qdoc3/test/qt-build-docs.qdocconf
index a13ea94..8cb22f9 100644
--- a/tools/qdoc3/test/qt-build-docs.qdocconf
+++ b/tools/qdoc3/test/qt-build-docs.qdocconf
@@ -107,7 +107,8 @@ exampledirs             = $QT_SOURCE_TREE/doc/src \
                           $QT_SOURCE_TREE \
                           $QT_SOURCE_TREE/qmake/examples
 imagedirs               = $QT_SOURCE_TREE/doc/src/images \
-                          $QT_SOURCE_TREE/examples
+                          $QT_SOURCE_TREE/examples \
+                          $QT_SOURCE_TREE/doc/src/declarative/pics
 outputdir               = $QT_BUILD_TREE/doc/html
 tagfile                 = $QT_BUILD_TREE/doc/html/qt.tags
 base                    = file:$QT_BUILD_TREE/doc/html
diff --git a/tools/qdoc3/test/qt.qdocconf b/tools/qdoc3/test/qt.qdocconf
index e07882c..f834979 100644
--- a/tools/qdoc3/test/qt.qdocconf
+++ b/tools/qdoc3/test/qt.qdocconf
@@ -109,7 +109,8 @@ exampledirs             = $QTDIR/doc/src \
                           $QTDIR \
                           $QTDIR/qmake/examples
 imagedirs               = $QTDIR/doc/src/images \
-                          $QTDIR/examples
+                          $QTDIR/examples \
+			  $QTDIR/doc/src/declarative/pics
 outputdir               = $QTDIR/doc/html
 tagfile                 = $QTDIR/doc/html/qt.tags
 base                    = file:$QTDIR/doc/html
diff --git a/tools/qdoc3/tree.cpp b/tools/qdoc3/tree.cpp
index 0fbd438..539db51 100644
--- a/tools/qdoc3/tree.cpp
+++ b/tools/qdoc3/tree.cpp
@@ -176,6 +176,8 @@ const Node *Tree::findNode(const QStringList &path,
 }
 
 /*!
+  Find the node with the specified \a path name of the
+  specified \a type.
  */
 Node *Tree::findNode(const QStringList &path,
                      Node::Type type,
@@ -189,6 +191,8 @@ Node *Tree::findNode(const QStringList &path,
 }
 
 /*!
+  Find the node with the specified \a path name of the
+  specified \a type.
  */
 const Node *Tree::findNode(const QStringList &path,
                            Node::Type type,
@@ -208,7 +212,9 @@ FunctionNode *Tree::findFunctionNode(const QStringList& path,
                                      int findFlags)
 {
     return const_cast<FunctionNode *>(
-                const_cast<const Tree *>(this)->findFunctionNode(path, relative, findFlags));
+                const_cast<const Tree *>(this)->findFunctionNode(path,
+                                                                 relative,
+                                                                 findFlags));
 }
 
 /*!
@@ -233,7 +239,8 @@ const FunctionNode *Tree::findFunctionNode(const QStringList &path,
             else
                 next = ((InnerNode *) node)->findNode(path.at(i));
 
-            if (!next && node->type() == Node::Class && (findFlags & SearchBaseClasses)) {
+            if (!next && node->type() == Node::Class &&
+                (findFlags & SearchBaseClasses)) {
                 NodeList baseClasses = allBaseClasses(static_cast<const ClassNode *>(node));
                 foreach (const Node *baseClass, baseClasses) {
                     if (i == path.size() - 1)
@@ -563,7 +570,7 @@ void Tree::resolveGroups()
 
         FakeNode *fake =
             static_cast<FakeNode*>(findNode(QStringList(i.key()),Node::Fake));
-        if (fake && fake->subType() == FakeNode::Group) {
+        if (fake && fake->subType() == Node::Group) {
             fake->addGroupMember(i.value());
         }
         else {
@@ -770,21 +777,21 @@ void Tree::readIndexSection(const QDomElement &element,
 
     }
     else if (element.nodeName() == "page") {
-        FakeNode::SubType subtype;
+        Node::SubType subtype;
         if (element.attribute("subtype") == "example")
-            subtype = FakeNode::Example;
+            subtype = Node::Example;
         else if (element.attribute("subtype") == "header")
-            subtype = FakeNode::HeaderFile;
+            subtype = Node::HeaderFile;
         else if (element.attribute("subtype") == "file")
-            subtype = FakeNode::File;
+            subtype = Node::File;
         else if (element.attribute("subtype") == "group")
-            subtype = FakeNode::Group;
+            subtype = Node::Group;
         else if (element.attribute("subtype") == "module")
-            subtype = FakeNode::Module;
+            subtype = Node::Module;
         else if (element.attribute("subtype") == "page")
-            subtype = FakeNode::Page;
+            subtype = Node::Page;
         else if (element.attribute("subtype") == "externalpage")
-            subtype = FakeNode::ExternalPage;
+            subtype = Node::ExternalPage;
         else
             return;
 
@@ -1226,25 +1233,25 @@ bool Tree::generateIndexSection(QXmlStreamWriter &writer,
 
             const FakeNode *fakeNode = static_cast<const FakeNode*>(node);
             switch (fakeNode->subType()) {
-                case FakeNode::Example:
+                case Node::Example:
                     writer.writeAttribute("subtype", "example");
                     break;
-                case FakeNode::HeaderFile:
+                case Node::HeaderFile:
                     writer.writeAttribute("subtype", "header");
                     break;
-                case FakeNode::File:
+                case Node::File:
                     writer.writeAttribute("subtype", "file");
                     break;
-                case FakeNode::Group:
+                case Node::Group:
                     writer.writeAttribute("subtype", "group");
                     break;
-                case FakeNode::Module:
+                case Node::Module:
                     writer.writeAttribute("subtype", "module");
                     break;
-                case FakeNode::Page:
+                case Node::Page:
                     writer.writeAttribute("subtype", "page");
                     break;
-                case FakeNode::ExternalPage:
+                case Node::ExternalPage:
                     writer.writeAttribute("subtype", "externalpage");
                     break;
                 default:
@@ -1383,7 +1390,7 @@ bool Tree::generateIndexSection(QXmlStreamWriter &writer,
             bool external = false;
             if (inner->type() == Node::Fake) {
                 const FakeNode *fakeNode = static_cast<const FakeNode *>(inner);
-                if (fakeNode->subType() == FakeNode::ExternalPage)
+                if (fakeNode->subType() == Node::ExternalPage)
                     external = true;
             }
 
@@ -1863,7 +1870,7 @@ void Tree::generateTagFile(const QString &fileName) const
  */
 void Tree::addExternalLink(const QString &url, const Node *relative)
 {
-    FakeNode *fakeNode = new FakeNode(root(), url, FakeNode::ExternalPage);
+    FakeNode *fakeNode = new FakeNode(root(), url, Node::ExternalPage);
     fakeNode->setAccess(Node::Public);
 
     // Create some content for the node.
@@ -1894,9 +1901,8 @@ QString Tree::fullDocumentLocation(const Node *node) const
         else
             return "";
     }
-    else if (node->type() == Node::Fake) {
+    else if (node->type() == Node::Fake)
         return node->fileBase() + ".html";
-    }
     else if (node->fileBase().isEmpty())
         return "";
 
diff --git a/tools/qdoc3/webxmlgenerator.cpp b/tools/qdoc3/webxmlgenerator.cpp
index 0438adf..cf0995f 100644
--- a/tools/qdoc3/webxmlgenerator.cpp
+++ b/tools/qdoc3/webxmlgenerator.cpp
@@ -191,7 +191,7 @@ void WebXMLGenerator::generateIndexSections(QXmlStreamWriter &writer,
 
             generateRelations(writer, node, marker);
 
-            if (fake->subType() == FakeNode::Module) {
+            if (fake->subType() == Node::Module) {
                 writer.writeStartElement("generatedlist");
                 writer.writeAttribute("contents", "classesbymodule");
 
@@ -264,7 +264,7 @@ void WebXMLGenerator::generateInnerNode(const InnerNode *node, CodeMarker *marke
 
     if (node->type() == Node::Fake) {
         const FakeNode *fakeNode = static_cast<const FakeNode *>(node);
-        if (fakeNode->subType() == FakeNode::ExternalPage)
+        if (fakeNode->subType() == Node::ExternalPage)
             return;
     }
 
diff --git a/tools/tools.pro b/tools/tools.pro
index c76174c..a531f85 100644
--- a/tools/tools.pro
+++ b/tools/tools.pro
@@ -24,6 +24,7 @@ mac {
 
 SUBDIRS += kmap2qmap
 
+contains(QT_CONFIG, declarative):SUBDIRS += duiviewer
 contains(QT_CONFIG, dbus):SUBDIRS += qdbus
 !wince*:contains(QT_CONFIG, xmlpatterns): SUBDIRS += xmlpatterns
 embedded: SUBDIRS += makeqpf