Merge branch 'kinetic-declarativeui' of git://git-nokia.trolltech.com.au/qtsoftware/qt/kinetic

Conflicts:
	src/xmlpatterns/type/qprimitives_p.h
	tools/linguist/lupdate/main.cpp

51 files changed, 7926 insertions, 7 deletions

diff --git a/tools/linguist/lupdate/lupdate.h b/tools/linguist/lupdate/lupdate.h
index 70332cd..136884b 100644
--- a/tools/linguist/lupdate/lupdate.h
+++ b/tools/linguist/lupdate/lupdate.h
@@ -79,6 +79,7 @@ void loadCPP(Translator &translator, const QStringList &filenames, ConversionDat
 bool loadJava(Translator &translator, const QString &filename, ConversionData &cd);
 bool loadQScript(Translator &translator, const QString &filename, ConversionData &cd);
 bool loadUI(Translator &translator, const QString &filename, ConversionData &cd);
+bool loadQml(Translator &translator, const QString &filename, ConversionData &cd);
 
 QT_END_NAMESPACE
 
diff --git a/tools/linguist/lupdate/lupdate.pro b/tools/linguist/lupdate/lupdate.pro
index ccc2d47..283d69f 100644
--- a/tools/linguist/lupdate/lupdate.pro
+++ b/tools/linguist/lupdate/lupdate.pro
@@ -15,6 +15,9 @@ build_all:!build_pass {
 include(../shared/formats.pri)
 include(../shared/proparser.pri)
 
+include($$QT_SOURCE_TREE/src/declarative/qml/parser/parser.pri)
+INCLUDEPATH += $$QT_SOURCE_TREE/src/declarative/qml
+
 SOURCES += \
     main.cpp \
     merge.cpp \
@@ -23,6 +26,7 @@ SOURCES += \
     cpp.cpp \
     java.cpp \
     qscript.cpp \
+    qml.cpp \
     ui.cpp
 
 HEADERS += \
diff --git a/tools/linguist/lupdate/main.cpp b/tools/linguist/lupdate/main.cpp
index c9f4a05..0003baa 100644
--- a/tools/linguist/lupdate/main.cpp
+++ b/tools/linguist/lupdate/main.cpp
@@ -269,6 +269,8 @@ static void processSources(Translator &fetchedTor,
         else if (it->endsWith(QLatin1String(".js"), Qt::CaseInsensitive)
                  || it->endsWith(QLatin1String(".qs"), Qt::CaseInsensitive))
             loadQScript(fetchedTor, *it, cd);
+        else if (it->endsWith(QLatin1String(".qml"), Qt::CaseInsensitive))
+            loadQml(fetchedTor, *it, cd);
         else
             sourceFilesCpp << *it;
     }
@@ -634,7 +636,8 @@ int main(int argc, char **argv)
                         if (!fn.endsWith(QLatin1String(".java"))
                             && !fn.endsWith(QLatin1String(".ui"))
                             && !fn.endsWith(QLatin1String(".js"))
-                            && !fn.endsWith(QLatin1String(".qs"))) {
+                            && !fn.endsWith(QLatin1String(".qs"))
+                            && !fn.endsWith(QLatin1String(".qml"))) {
                             int offset = 0;
                             int depth = 0;
                             do {
diff --git a/tools/linguist/lupdate/qml.cpp b/tools/linguist/lupdate/qml.cpp
new file mode 100644
index 0000000..860d87c
--- /dev/null
+++ b/tools/linguist/lupdate/qml.cpp
@@ -0,0 +1,240 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt Linguist of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "lupdate.h"
+
+#include <translator.h>
+
+#include <QtCore/QDebug>
+#include <QtCore/QFile>
+#include <QtCore/QString>
+
+#include "parser/qmljsengine_p.h"
+#include "parser/qmljsparser_p.h"
+#include "parser/qmljslexer_p.h"
+#include "parser/qmljsnodepool_p.h"
+#include "parser/qmljsastvisitor_p.h"
+#include "parser/qmljsast_p.h"
+
+#include <QCoreApplication>
+#include <QFile>
+#include <QFileInfo>
+#include <QtDebug>
+#include <QStringList>
+
+#include <iostream>
+#include <cstdlib>
+
+QT_BEGIN_NAMESPACE
+
+using namespace QmlJS;
+
+class FindTrCalls: protected AST::Visitor
+{
+public:
+    void operator()(Translator *translator, const QString &fileName, AST::Node *node)
+    {
+        m_translator = translator;
+        m_fileName = fileName;
+        m_component = QFileInfo(fileName).baseName();   //matches qsTr usage in QScriptEngine
+        accept(node);
+    }
+
+protected:
+    using AST::Visitor::visit;
+    using AST::Visitor::endVisit;
+
+    void accept(AST::Node *node)
+    { AST::Node::acceptChild(node, this); }
+
+    virtual void endVisit(AST::CallExpression *node)
+    {
+        if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(node->base)) {
+            if (idExpr->name->asString() == QLatin1String("qsTr") ||
+                idExpr->name->asString() == QLatin1String("QT_TR_NOOP")) {
+                if (node->arguments && AST::cast<AST::StringLiteral *>(node->arguments->expression)) {
+                    AST::StringLiteral *literal = AST::cast<AST::StringLiteral *>(node->arguments->expression);
+                    const QString source = literal->value->asString();
+
+                    QString comment;
+                    bool plural = false;
+                    AST::ArgumentList *commentNode = node->arguments->next;
+                    if (commentNode) {
+                        literal = AST::cast<AST::StringLiteral *>(commentNode->expression);
+                        comment = literal->value->asString();
+
+                        AST::ArgumentList *nNode = commentNode->next;
+                        if (nNode) {
+                            AST::NumericLiteral *numLiteral = AST::cast<AST::NumericLiteral *>(nNode->expression);
+                            if (numLiteral) {
+                                plural = true;
+                            }
+                        }
+                    }
+
+                    TranslatorMessage msg(m_component, source,
+                        comment, QString(), m_fileName,
+                        node->firstSourceLocation().startLine, QStringList(),
+                        TranslatorMessage::Unfinished, plural);
+                    m_translator->extend(msg);
+                }
+            } else if (idExpr->name->asString() == QLatin1String("qsTranslate") ||
+                       idExpr->name->asString() == QLatin1String("QT_TRANSLATE_NOOP")) {
+                if (node->arguments && AST::cast<AST::StringLiteral *>(node->arguments->expression)) {
+                    AST::StringLiteral *literal = AST::cast<AST::StringLiteral *>(node->arguments->expression);
+                    const QString context = literal->value->asString();
+
+                    QString source;
+                    QString comment;
+                    bool plural = false;
+                    AST::ArgumentList *sourceNode = node->arguments->next;
+                    if (sourceNode) {
+                        literal = AST::cast<AST::StringLiteral *>(sourceNode->expression);
+                        source = literal->value->asString();
+                        AST::ArgumentList *commentNode = sourceNode->next;
+                        if (commentNode) {
+                            literal = AST::cast<AST::StringLiteral *>(commentNode->expression);
+                            comment = literal->value->asString();
+
+                            AST::ArgumentList *nNode = commentNode->next;
+                            if (nNode) {
+                                AST::NumericLiteral *numLiteral = AST::cast<AST::NumericLiteral *>(nNode->expression);
+                                if (numLiteral) {
+                                    plural = true;
+                                }
+                            }
+                        }
+                    }
+
+                    TranslatorMessage msg(context, source,
+                        comment, QString(), m_fileName,
+                        node->firstSourceLocation().startLine, QStringList(),
+                        TranslatorMessage::Unfinished, plural);
+                    m_translator->extend(msg);
+                }
+
+            }
+        }
+    }
+
+private:
+    Translator *m_translator;
+    QString m_fileName;
+    QString m_component;
+};
+
+QString createErrorString(const QString &filename, const QString &code, Parser &parser)
+{
+    // print out error
+    QStringList lines = code.split(QLatin1Char('\n'));
+    lines.append(QLatin1String("\n")); // sentinel.
+    QString errorString;
+
+    foreach (const DiagnosticMessage &m, parser.diagnosticMessages()) {
+
+        if (m.isWarning())
+            continue;
+
+        QString error = filename + QLatin1Char(':') + QString::number(m.loc.startLine)
+                        + QLatin1Char(':') + QString::number(m.loc.startColumn) + QLatin1String(": error: ")
+                        + m.message + QLatin1Char('\n');
+
+        int line = 0;
+        if (m.loc.startLine > 0)
+            line = m.loc.startLine - 1;
+
+        const QString textLine = lines.at(line);
+
+        error += textLine + QLatin1Char('\n');
+
+        int column = m.loc.startColumn - 1;
+        if (column < 0)
+            column = 0;
+
+        column = qMin(column, textLine.length());
+
+        for (int i = 0; i < column; ++i) {
+            const QChar ch = textLine.at(i);
+            if (ch.isSpace())
+                error += ch.unicode();
+            else
+                error += QLatin1Char(' ');
+        }
+        error += QLatin1String("^\n");
+        errorString += error;
+    }
+    return errorString;
+}
+
+bool loadQml(Translator &translator, const QString &filename, ConversionData &cd)
+{
+    cd.m_sourceFileName = filename;
+    QFile file(filename);
+    if (!file.open(QIODevice::ReadOnly)) {
+        cd.appendError(QString::fromLatin1("Cannot open %1: %2")
+            .arg(filename, file.errorString()));
+        return false;
+    }
+
+    const QString code = QTextStream(&file).readAll();
+
+    Engine driver;
+    Parser parser(&driver);
+
+    NodePool nodePool(filename, &driver);
+    driver.setNodePool(&nodePool);
+
+    Lexer lexer(&driver);
+    lexer.setCode(code, /*line = */ 1);
+    driver.setLexer(&lexer);
+
+    if (parser.parse()) {
+        FindTrCalls trCalls;
+        trCalls(&translator, filename, parser.ast());
+    } else {
+        QString error = createErrorString(filename, code, parser);
+        cd.appendError(error);
+        return false;
+    }
+    return true;
+}
+
+QT_END_NAMESPACE
diff --git a/tools/qdoc3/cppcodemarker.cpp b/tools/qdoc3/cppcodemarker.cpp
index 2df7133..d9c767a 100644
--- a/tools/qdoc3/cppcodemarker.cpp
+++ b/tools/qdoc3/cppcodemarker.cpp
@@ -1129,7 +1129,7 @@ QList<Section> CppCodeMarker::qmlSections(const QmlClassNode* qmlClassNode,
                                 "signal",
                                 "signals");
 	    FastSection qmlattachedsignals(qmlClassNode,
-                                           "QML Attached Signals",
+                                           "Attached Signals",
                                            "signal",
                                            "signals");
 	    FastSection qmlmethods(qmlClassNode,
@@ -1137,7 +1137,7 @@ QList<Section> CppCodeMarker::qmlSections(const QmlClassNode* qmlClassNode,
                                    "method",
                                    "methods");
 	    FastSection qmlattachedmethods(qmlClassNode,
-                                           "QML Attached Methods",
+                                           "Attached Methods",
                                            "method",
                                            "methods");
 
diff --git a/tools/qdoc3/test/qml.qdocconf b/tools/qdoc3/test/qml.qdocconf
new file mode 100644
index 0000000..3b5d8dc
--- /dev/null
+++ b/tools/qdoc3/test/qml.qdocconf
@@ -0,0 +1,80 @@
+include(compat.qdocconf)
+include(macros.qdocconf)
+include(qt-cpp-ignore.qdocconf)
+include(qt-html-templates.qdocconf)
+include(qt-defines.qdocconf)
+
+project                 = Qml
+description             = Qml Reference Documentation
+url                     = http://doc.qtsoftware.com/4.6
+qmlonly                 = true
+
+edition.Console.modules = QtCore QtDBus QtNetwork QtScript QtSql QtXml \
+                          QtXmlPatterns QtTest
+edition.Desktop.modules = QtCore QtDBus QtGui QtNetwork QtOpenGL QtScript QtSql QtSvg \
+                          QtWebKit QtXml QtXmlPatterns Qt3Support QtHelp \
+                          QtDesigner QtAssistant QAxContainer Phonon \
+                          QAxServer QtUiTools QtTest QtDBus
+edition.DesktopLight.modules = QtCore QtDBus QtGui Qt3SupportLight QtTest
+edition.DesktopLight.groups       = -graphicsview-api
+
+qhp.projects            = Qml
+
+qhp.Qml.file                = qml.qhp
+qhp.Qml.namespace           = com.trolltech.qml.460
+qhp.Qml.virtualFolder       = qdoc
+qhp.Qml.indexTitle          = Qml Reference
+
+# Files not referenced in any qdoc file
+# See also extraimages.HTML
+qhp.Qml.extraFiles          = classic.css \
+                             images/qt-logo.png
+
+qhp.Qml.filterAttributes    = qt 4.6.0 qtrefdoc
+qhp.Qml.customFilters.Qt.name = Qt 4.6.0
+qhp.Qml.customFilters.Qt.filterAttributes = qt 4.6.0
+qhp.Qml.subprojects         = classes
+qhp.Qml.subprojects.classes.title = Elements
+qhp.Qml.subprojects.classes.indexTitle = Qml Elements
+qhp.Qml.subprojects.classes.selectors = fake:qmlclass
+qhp.Qml.subprojects.classes.sortPages = true
+
+language                = Cpp
+
+headerdirs              = $QT_SOURCE_TREE/src/declarative
+sourcedirs              = $QT_SOURCE_TREE/src/declarative \
+                          $QT_SOURCE_TREE/doc/src/declarative
+
+sources += $QT_SOURCE_TREE/doc/src/tutorials/declarative.qdoc
+
+sources.fileextensions  = "*.cpp *.qdoc"
+examples.fileextensions = "*.cpp *.h *.js *.qml"
+
+exampledirs             = $QT_SOURCE_TREE/doc/src \
+                          $QT_SOURCE_TREE/examples \
+                          $QT_SOURCE_TREE/examples/tutorials \
+                          $QT_SOURCE_TREE \
+                          $QT_SOURCE_TREE/qmake/examples \
+                          $QT_SOURCE_TREE/src/3rdparty/webkit/WebKit/qt/docs
+imagedirs               = $QT_SOURCE_TREE/doc/src/images \
+                          $QT_SOURCE_TREE/examples \
+                          $QT_SOURCE_TREE/doc/src/declarative/pics
+outputdir               = $QT_BUILD_TREE/doc-build/html-qml
+tagfile                 = $QT_BUILD_TREE/doc-build/html-qml/qt.tags
+base                    = file:$QT_BUILD_TREE/doc/html-qml
+
+HTML.stylesheets        = classic.css
+
+HTML.postheader         = "<table border=\"0\" cellpadding=\"0\" cellspacing=\"0\">\n" \
+                          "<tr>\n" \
+                          "<td align=\"left\" valign=\"top\">" \
+                          "<img src=\"images/qt-logo.png\" align=\"left\" border=\"0\"/>" \
+                          "</td>\n" \
+                          "<td width=\"1\">&nbsp;&nbsp;</td>" \
+                          "<td class=\"postheader\" valign=\"center\" align=\"left\">" \
+                          "<a href=\"qmlreference.html\">" \
+                          "<font color=\"#004faf\">Home</font></a>&nbsp;&middot;" \
+                          " <a href=\"qmlelements.html\">" \
+                          "<font color=\"#004faf\">Elements</font></a>" \
+                          "</td>\n" \
+                          "</tr></table>"
diff --git a/tools/qdoc3/test/qt-build-docs.qdocconf b/tools/qdoc3/test/qt-build-docs.qdocconf
index e8595f6..6cc27b6 100644
--- a/tools/qdoc3/test/qt-build-docs.qdocconf
+++ b/tools/qdoc3/test/qt-build-docs.qdocconf
@@ -97,7 +97,7 @@ excludedirs             = $QT_SOURCE_TREE/src/3rdparty/clucene \
                           $QT_SOURCE_TREE/src/3rdparty/phonon/waveout
 
 sources.fileextensions  = "*.cpp *.qdoc *.mm"
-examples.fileextensions = "*.cpp *.h *.js *.xq *.svg *.xml *.ui *.qhp *.qhcp"
+examples.fileextensions = "*.cpp *.h *.js *.xq *.svg *.xml *.ui *.qhp *.qhcp *.qml"
 examples.imageextensions = "*.png"
 
 exampledirs             = $QT_SOURCE_TREE/doc/src \
@@ -107,7 +107,8 @@ exampledirs             = $QT_SOURCE_TREE/doc/src \
                           $QT_SOURCE_TREE/qmake/examples \
                           $QT_SOURCE_TREE/src/3rdparty/webkit/WebKit/qt/docs
 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 a066021..b65ac56 100644
--- a/tools/qdoc3/test/qt.qdocconf
+++ b/tools/qdoc3/test/qt.qdocconf
@@ -99,7 +99,7 @@ excludedirs             = $QTDIR/src/3rdparty/clucene \
                           $QTDIR/src/3rdparty/phonon/waveout
 
 sources.fileextensions  = "*.cpp *.qdoc *.mm"
-examples.fileextensions = "*.cpp *.h *.js *.xq *.svg *.xml *.ui *.qhp *.qhcp"
+examples.fileextensions = "*.cpp *.h *.js *.xq *.svg *.xml *.ui *.qhp *.qhcp *.qml"
 examples.imageextensions = "*.png"
 
 exampledirs             = $QTDIR/doc/src \
@@ -109,7 +109,8 @@ exampledirs             = $QTDIR/doc/src \
                           $QTDIR/qmake/examples \
                           $QTDIR/src/3rdparty/webkit/WebKit/qt/docs
 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/qmldebugger/qmldebugger.pro b/tools/qmldebugger/qmldebugger.pro
new file mode 100644
index 0000000..679cae6
--- /dev/null
+++ b/tools/qmldebugger/qmldebugger.pro
@@ -0,0 +1,5 @@
+TEMPLATE = subdirs
+CONFIG += ordered
+
+SUBDIRS = standalone
+
diff --git a/tools/qmldebugger/standalone/canvasframerate.cpp b/tools/qmldebugger/standalone/canvasframerate.cpp
new file mode 100644
index 0000000..d956029
--- /dev/null
+++ b/tools/qmldebugger/standalone/canvasframerate.cpp
@@ -0,0 +1,581 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <QtCore/qdebug.h>
+#include <QtCore/qstringlist.h>
+#include <QtCore/qdatastream.h>
+#include <QtCore/qmargins.h>
+
+#include <QtGui/qapplication.h>
+#include <QtGui/qpainter.h>
+#include <QtGui/qtooltip.h>
+#include <QtGui/qslider.h>
+#include <QtGui/qscrollbar.h>
+#include <QtGui/qspinbox.h>
+#include <QtGui/qgroupbox.h>
+#include <QtGui/qboxlayout.h>
+#include <QtGui/qlabel.h>
+#include <QtGui/qlineedit.h>
+#include <QtGui/qpushbutton.h>
+#include <QtGui/qtabwidget.h>
+
+#include <QResizeEvent>
+#include <QShowEvent>
+
+#include <private/qmldebugclient_p.h>
+#include "canvasframerate.h"
+
+QT_BEGIN_NAMESPACE
+
+class QLineGraph : public QWidget
+{
+Q_OBJECT
+public:
+    QLineGraph(QAbstractSlider *slider, QWidget * = 0);
+
+    void setPosition(int);
+
+public slots:
+    void addSample(int, int, int, bool);
+    void setResolutionForHeight(int);
+    void clear();
+
+protected:
+    virtual void paintEvent(QPaintEvent *);
+    virtual void mouseMoveEvent(QMouseEvent *);
+    virtual void leaveEvent(QEvent *);
+    virtual void wheelEvent(QWheelEvent *event);
+
+private slots:
+    void sliderChanged(int);
+
+private:
+    void updateSlider();
+    void drawSample(QPainter *, int, const QRect &, QList<QRect> *);
+    void drawTime(QPainter *, const QRect &);
+    QRect findContainingRect(const QList<QRect> &rects, const QPoint &pos) const;
+    struct Sample { 
+        int sample[3];
+        bool isBreak;
+    };
+    QList<Sample> _samples;
+
+    QAbstractSlider *slider;
+    int position;
+    int samplesPerWidth;
+    int resolutionForHeight;
+    bool ignoreScroll;
+    QMargins graphMargins;
+
+    QList<QRect> rectsPaintTime;    // time to do a paintEvent()
+    QList<QRect> rectsTimeBetween;  // time between frames
+    QRect highlightedBar;
+};
+
+QLineGraph::QLineGraph(QAbstractSlider *slider, QWidget *parent)
+: QWidget(parent), slider(slider), position(-1), samplesPerWidth(99), resolutionForHeight(50),
+  ignoreScroll(false), graphMargins(65, 10, 71, 35)
+{
+    setMouseTracking(true);
+
+    slider->setMaximum(0);
+    slider->setMinimum(0);
+    slider->setSingleStep(1);
+    
+    connect(slider, SIGNAL(valueChanged(int)), this, SLOT(sliderChanged(int)));
+}
+
+void QLineGraph::sliderChanged(int v)
+{
+    if(ignoreScroll)
+        return;
+
+    if (v == slider->maximum())
+        position = -1;
+    else
+        position = v;
+    
+    update();
+    
+    // update highlightedRect
+    QPoint pos = mapFromGlobal(QCursor::pos());
+    if (geometry().contains(pos)) {
+        QMouseEvent *me = new QMouseEvent(QEvent::MouseMove, pos,
+                Qt::NoButton, Qt::NoButton, Qt::NoModifier);
+        QApplication::postEvent(this, me);
+    }
+}
+
+void QLineGraph::clear()
+{
+    _samples.clear();
+    rectsPaintTime.clear();
+    rectsTimeBetween.clear();
+    highlightedBar = QRect();
+    position = -1;
+
+    updateSlider();
+    update();
+}
+
+void QLineGraph::updateSlider()
+{
+    ignoreScroll = true;
+    slider->setMaximum(qMax(0, _samples.count() - samplesPerWidth - 1));
+
+    if(position == -1) {
+        slider->setValue(slider->maximum());
+    } else {
+        slider->setValue(position);
+    }    
+    ignoreScroll = false;
+}
+
+void QLineGraph::addSample(int a, int b, int d, bool isBreak)
+{
+    Sample s;
+    s.isBreak = isBreak;
+    s.sample[0] = a;
+    s.sample[1] = b;
+    s.sample[2] = d;
+    _samples << s;
+    updateSlider();
+    update();
+}
+
+void QLineGraph::setPosition(int p)
+{
+    sliderChanged(p);
+}
+
+void QLineGraph::drawTime(QPainter *p, const QRect &rect)
+{
+    if(_samples.isEmpty())
+        return;
+
+    int first = position;
+    if(first == -1)
+        first = qMax(0, _samples.count() - samplesPerWidth - 1);
+    int last = qMin(_samples.count() - 1, first + samplesPerWidth);
+
+    qreal scaleX = qreal(rect.width()) / qreal(samplesPerWidth);
+
+    int t = 0;
+
+    for(int ii = first; ii <= last; ++ii) {
+        int sampleTime = _samples.at(ii).sample[2] / 1000;
+        if(sampleTime != t) {
+
+            int xEnd = rect.left() + scaleX * (ii - first);
+            p->drawLine(xEnd, rect.bottom(), xEnd, rect.bottom() + 7);
+
+            QRect text(xEnd - 30, rect.bottom() + 10, 60, 30);
+
+            p->drawText(text, Qt::AlignHCenter | Qt::AlignTop, QString::number(_samples.at(ii).sample[2]));
+
+            t = sampleTime;
+        }
+    }
+
+}
+
+void QLineGraph::drawSample(QPainter *p, int s, const QRect &rect, QList<QRect> *record)
+{
+    if(_samples.isEmpty())
+        return;
+
+    int first = position;
+    if(first == -1)
+        first = qMax(0, _samples.count() - samplesPerWidth - 1);
+    int last = qMin(_samples.count() - 1, first + samplesPerWidth);
+
+    qreal scaleY = qreal(rect.height()) / resolutionForHeight;
+    qreal scaleX = qreal(rect.width()) / qreal(samplesPerWidth);
+
+    int xEnd;
+    int lastXEnd = rect.left();
+
+    p->save();
+    p->setPen(Qt::NoPen);
+    for(int ii = first + 1; ii <= last; ++ii) {
+
+        xEnd = rect.left() + scaleX * (ii - first);
+        int yEnd = rect.bottom() - _samples.at(ii).sample[s] * scaleY;
+
+        if (!(s == 0 && _samples.at(ii).isBreak)) {
+            QRect bar(lastXEnd, yEnd, scaleX, _samples.at(ii).sample[s] * scaleY);
+            record->append(bar);
+            p->drawRect(bar);
+        }
+
+        lastXEnd = xEnd;
+    }
+    p->restore();
+}
+
+void QLineGraph::paintEvent(QPaintEvent *)
+{
+    QPainter p(this);
+    p.setRenderHint(QPainter::Antialiasing);
+
+    QRect r(graphMargins.left(), graphMargins.top(),
+            width() - graphMargins.right(), height() - graphMargins.bottom());
+
+    p.save();
+    p.rotate(-90);
+    p.translate(-r.height()/2 - r.width()/2 - graphMargins.right(), -r.height()/2);
+    p.drawText(r, Qt::AlignCenter, tr("Frame rate"));
+    p.restore();
+
+    p.setBrush(QColor("lightsteelblue"));
+    rectsTimeBetween.clear();
+    drawSample(&p, 0, r, &rectsTimeBetween);
+
+    p.setBrush(QColor("pink"));
+    rectsPaintTime.clear();
+    drawSample(&p, 1, r, &rectsPaintTime);
+
+    if (!highlightedBar.isNull()) {
+        p.setBrush(Qt::darkGreen);
+        p.drawRect(highlightedBar);
+    }
+
+    p.setBrush(Qt::NoBrush);
+    p.drawRect(r);
+
+    slider->setGeometry(x() + r.x(), slider->y(), r.width(), slider->height());
+
+    for(int ii = 0; ii <= resolutionForHeight; ++ii) {
+        int y = 1 + r.bottom() - ii * r.height() / resolutionForHeight;
+
+        if((ii % 10) == 0) {
+            p.drawLine(r.left() - 20, y, r.left(), y);
+            QRect text(r.left() - 20 - 53, y - 10, 50, 20);
+            p.drawText(text, Qt::AlignRight | Qt::AlignVCenter, QString::number(ii));
+        } else {
+            p.drawLine(r.left() - 7, y, r.left(), y);
+        }
+    }
+
+    drawTime(&p, r);
+}
+
+void QLineGraph::mouseMoveEvent(QMouseEvent *event)
+{
+    QPoint pos = event->pos();
+
+    QRect rect = findContainingRect(rectsPaintTime, pos);
+    if (rect.isNull())
+        rect = findContainingRect(rectsTimeBetween, pos);
+
+    if (!highlightedBar.isNull())
+        update(highlightedBar.adjusted(-1, -1, 1, 1));
+    highlightedBar = rect;
+
+    if (!rect.isNull()) {
+        QRect graph(graphMargins.left(), graphMargins.top(),
+                    width() - graphMargins.right(), height() - graphMargins.bottom());
+        qreal scaleY = qreal(graph.height()) / resolutionForHeight;
+        QToolTip::showText(event->globalPos(), QString::number(qRound(rect.height() / scaleY)), this, rect);
+        update(rect.adjusted(-1, -1, 1, 1));
+    }
+}
+
+void QLineGraph::leaveEvent(QEvent *)
+{
+    if (!highlightedBar.isNull()) {
+        QRect bar = highlightedBar.adjusted(-1, -1, 1, 1);
+        highlightedBar = QRect();
+        update(bar);
+    }
+}
+
+void QLineGraph::wheelEvent(QWheelEvent *event)
+{
+    QWheelEvent we(QPoint(0,0), event->delta(), event->buttons(), event->modifiers(), event->orientation());
+    QApplication::sendEvent(slider, &we);
+}
+
+void QLineGraph::setResolutionForHeight(int resolution)
+{
+    resolutionForHeight = resolution;
+    update();
+}
+
+QRect QLineGraph::findContainingRect(const QList<QRect> &rects, const QPoint &pos) const
+{
+    for (int i=0; i<rects.count(); i++) {
+        if (rects[i].contains(pos))
+            return rects[i]; 
+    }
+    return QRect();
+}
+
+
+class GraphWindow : public QWidget
+{
+    Q_OBJECT
+public:
+    GraphWindow(QWidget *parent = 0);
+
+    virtual QSize sizeHint() const;
+
+public slots:
+    void addSample(int, int, int, bool);
+    void setResolutionForHeight(int);
+    void clear();
+
+private:
+    QLineGraph *m_graph;
+};
+
+GraphWindow::GraphWindow(QWidget *parent)
+    : QWidget(parent)
+{
+    QSlider *scroll = new QSlider(Qt::Horizontal);
+    scroll->setFocusPolicy(Qt::WheelFocus);
+    m_graph = new QLineGraph(scroll);
+
+    setFocusPolicy(Qt::WheelFocus);
+    setFocusProxy(scroll);
+
+    QVBoxLayout *layout = new QVBoxLayout(this);
+    layout->setContentsMargins(0, 0, 5, 0);
+    layout->setSpacing(0);
+    layout->addWidget(m_graph, 2);
+    layout->addWidget(new QLabel(tr("Total time elapsed (ms)")), 0, Qt::AlignHCenter);
+    layout->addWidget(scroll);
+}
+
+void GraphWindow::addSample(int a, int b, int d, bool isBreak)
+{
+    m_graph->addSample(a, b, d, isBreak);
+}
+
+void GraphWindow::setResolutionForHeight(int res)
+{
+    m_graph->setResolutionForHeight(res);
+}
+
+void GraphWindow::clear()
+{
+    m_graph->clear();
+}
+
+QSize GraphWindow::sizeHint() const
+{
+    return QSize(400, 220);
+}
+    
+
+class CanvasFrameRatePlugin : public QmlDebugClient
+{
+    Q_OBJECT
+public:
+    CanvasFrameRatePlugin(QmlDebugConnection *client);
+
+signals:
+    void sample(int, int, int, bool);
+
+protected:
+    virtual void messageReceived(const QByteArray &);
+
+private:
+    int lb;
+    int ld;
+};
+
+CanvasFrameRatePlugin::CanvasFrameRatePlugin(QmlDebugConnection *client)
+: QmlDebugClient(QLatin1String("CanvasFrameRate"), client), lb(-1)
+{
+}
+
+void CanvasFrameRatePlugin::messageReceived(const QByteArray &data)
+{
+    QByteArray rwData = data;
+    QDataStream stream(&rwData, QIODevice::ReadOnly);
+
+    int b; int c; int d; bool isBreak;
+    stream >> b >> c >> d >> isBreak;
+
+    if (lb != -1)
+        emit sample(c, lb, ld, isBreak);
+
+    lb = b;
+    ld = d;
+}
+
+CanvasFrameRate::CanvasFrameRate(QWidget *parent)
+: QWidget(parent),
+  m_plugin(0)
+{
+    m_tabs = new QTabWidget(this);
+
+    QHBoxLayout *bottom = new QHBoxLayout;
+    bottom->setMargin(0);
+    bottom->setSpacing(10);
+
+    m_res = new QSpinBox;
+    m_res->setRange(30, 200);
+    m_res->setValue(m_res->minimum());
+    m_res->setSingleStep(10);
+    m_res->setSuffix(QLatin1String("ms"));
+    bottom->addWidget(new QLabel(tr("Resolution:")));
+    bottom->addWidget(m_res);
+
+    bottom->addStretch();
+
+    m_clearButton = new QPushButton(tr("Clear"));
+    connect(m_clearButton, SIGNAL(clicked()), SLOT(clearGraph()));
+    bottom->addWidget(m_clearButton);
+
+    QPushButton *pb = new QPushButton(tr("New Graph"), this);
+    connect(pb, SIGNAL(clicked()), this, SLOT(newTab()));
+    bottom->addWidget(pb);
+    
+    m_group = new QGroupBox(tr("Enabled"));
+    m_group->setCheckable(true);
+    m_group->setChecked(false);
+    connect(m_group, SIGNAL(toggled(bool)), SLOT(enabledToggled(bool)));
+
+    QVBoxLayout *groupLayout = new QVBoxLayout(m_group);
+    groupLayout->setContentsMargins(5, 0, 5, 0);
+    groupLayout->setSpacing(2);
+    groupLayout->addWidget(m_tabs);
+    groupLayout->addLayout(bottom);
+    
+    QVBoxLayout *layout = new QVBoxLayout;
+    layout->setContentsMargins(0, 10, 0, 0);
+    layout->setSpacing(0);
+    layout->addWidget(m_group);
+    setLayout(layout);
+}
+
+void CanvasFrameRate::reset(QmlDebugConnection *conn)
+{
+    delete m_plugin;
+    m_plugin = 0;
+
+    QWidget *w;
+    for (int i=0; i<m_tabs->count(); i++) {
+        w = m_tabs->widget(i);
+        m_tabs->removeTab(i);
+        delete w;
+    }
+
+    if (conn) {
+        connect(conn, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
+                SLOT(connectionStateChanged(QAbstractSocket::SocketState)));
+        if (conn->state() == QAbstractSocket::ConnectedState)
+            handleConnected(conn);
+    }
+}
+
+void CanvasFrameRate::connectionStateChanged(QAbstractSocket::SocketState state)
+{
+    if (state == QAbstractSocket::UnconnectedState) {
+        delete m_plugin;
+        m_plugin = 0;
+    } else if (state == QAbstractSocket::ConnectedState) {
+        handleConnected(qobject_cast<QmlDebugConnection*>(sender()));
+    }        
+}
+
+void CanvasFrameRate::handleConnected(QmlDebugConnection *conn)
+{
+    delete m_plugin;
+    m_plugin = new CanvasFrameRatePlugin(conn);
+    enabledToggled(m_group->isChecked());
+    newTab();
+}
+
+void CanvasFrameRate::setSizeHint(const QSize &size)
+{
+    m_sizeHint = size;
+}
+
+QSize CanvasFrameRate::sizeHint() const
+{
+    return m_sizeHint;
+}
+
+void CanvasFrameRate::clearGraph()
+{
+    if (m_tabs->count()) {
+        GraphWindow *w = qobject_cast<GraphWindow*>(m_tabs->currentWidget());
+        if (w)
+            w->clear();
+    }
+}
+
+void CanvasFrameRate::newTab()
+{
+    if (!m_plugin)
+        return;
+
+    if (m_tabs->count()) {
+        QWidget *w = m_tabs->widget(m_tabs->count() - 1);
+        QObject::disconnect(m_plugin, SIGNAL(sample(int,int,int,bool)),
+                            w, SLOT(addSample(int,int,int,bool)));
+    }
+
+    int count = m_tabs->count();
+
+    GraphWindow *graph = new GraphWindow;
+    graph->setResolutionForHeight(m_res->value());
+    connect(m_plugin, SIGNAL(sample(int,int,int,bool)),
+            graph, SLOT(addSample(int,int,int,bool)));
+    connect(m_res, SIGNAL(valueChanged(int)),
+            graph, SLOT(setResolutionForHeight(int)));
+
+    QString name = QLatin1String("Graph ") + QString::number(count + 1);
+    m_tabs->addTab(graph, name);
+    m_tabs->setCurrentIndex(count);
+}
+
+void CanvasFrameRate::enabledToggled(bool checked)
+{
+    if (m_plugin)
+        static_cast<QmlDebugClient *>(m_plugin)->setEnabled(checked);
+}
+
+QT_END_NAMESPACE
+
+#include "canvasframerate.moc"
diff --git a/tools/qmldebugger/standalone/canvasframerate.h b/tools/qmldebugger/standalone/canvasframerate.h
new file mode 100644
index 0000000..f8eec59
--- /dev/null
+++ b/tools/qmldebugger/standalone/canvasframerate.h
@@ -0,0 +1,91 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef CANVASFRAMERATE_H
+#define CANVASFRAMERATE_H
+
+#include <QtCore/qpointer.h>
+#include <QtGui/qwidget.h>
+
+#include <private/qmldebugclient_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QTabWidget;
+class QSlider;
+class QGroupBox;
+class QLabel;
+class QSpinBox;
+class QPushButton;
+
+class CanvasFrameRatePlugin;
+
+class CanvasFrameRate : public QWidget
+{
+    Q_OBJECT
+public:
+    CanvasFrameRate(QWidget *parent = 0);
+    
+    void reset(QmlDebugConnection *conn);
+
+    void setSizeHint(const QSize &);
+    virtual QSize sizeHint() const;
+
+private slots:
+    void clearGraph();
+    void newTab();
+    void enabledToggled(bool);
+    void connectionStateChanged(QAbstractSocket::SocketState state);
+
+private:
+    void handleConnected(QmlDebugConnection *conn);
+
+    QGroupBox *m_group;
+    QTabWidget *m_tabs;
+    QSpinBox *m_res;
+    QPushButton *m_clearButton;
+    CanvasFrameRatePlugin *m_plugin;
+    QSize m_sizeHint;
+};
+
+QT_END_NAMESPACE
+
+#endif // CANVASFRAMERATE_H
+
diff --git a/tools/qmldebugger/standalone/engine.cpp b/tools/qmldebugger/standalone/engine.cpp
new file mode 100644
index 0000000..6cfd82b
--- /dev/null
+++ b/tools/qmldebugger/standalone/engine.cpp
@@ -0,0 +1,219 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QSplitter>
+#include <QTabWidget>
+#include <QFile>
+
+#include <private/qmlenginedebug_p.h>
+#include <private/qmldebugclient_p.h>
+#include <QtDeclarative/qmlcomponent.h>
+#include <QtDeclarative/qmlgraphicsitem.h>
+#include <private/qmldebugservice_p.h>
+
+#include "engine.h"
+#include "objectpropertiesview.h"
+#include "expressionquerywidget.h"
+#include "objecttree.h"
+#include "watchtable.h"
+
+QT_BEGIN_NAMESPACE
+
+
+class DebuggerEngineItem : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString name READ name CONSTANT);
+    Q_PROPERTY(int engineId READ engineId CONSTANT);
+
+public:
+    DebuggerEngineItem(const QString &name, int id)
+    : m_name(name), m_engineId(id) {}
+
+    QString name() const { return m_name; }
+    int engineId() const { return m_engineId; }
+
+private:
+    QString m_name;
+    int m_engineId;
+};
+
+EnginePane::EnginePane(QmlDebugConnection *conn, QWidget *parent)
+: QWidget(parent), m_client(new QmlEngineDebug(conn, this)), m_engines(0), m_context(0), m_watchTableModel(0), m_exprQueryWidget(0)
+{
+    QVBoxLayout *layout = new QVBoxLayout(this);
+    layout->setContentsMargins(0, 0, 0, 0);
+
+    QFile enginesFile(":/engines.qml");
+    enginesFile.open(QFile::ReadOnly);
+    Q_ASSERT(enginesFile.isOpen());
+
+    m_engineView = new QmlView(this);
+    m_engineView->rootContext()->setContextProperty("engines", qVariantFromValue(&m_engineItems));
+    m_engineView->setContentResizable(true);
+    m_engineView->setQml(enginesFile.readAll());
+    m_engineView->execute();
+    m_engineView->setFixedHeight(100);
+    QObject::connect(m_engineView->root(), SIGNAL(engineClicked(int)),
+                     this, SLOT(engineSelected(int)));
+    QObject::connect(m_engineView->root(), SIGNAL(refreshEngines()),
+                     this, SLOT(refreshEngines()));
+
+    m_engineView->setVisible(false);
+    layout->addWidget(m_engineView);
+
+    QSplitter *splitter = new QSplitter;
+
+    m_objTree = new ObjectTree(m_client, this);
+    m_propertiesView = new ObjectPropertiesView(m_client);
+    m_watchTableModel = new WatchTableModel(m_client, this);
+
+    m_watchTableView = new WatchTableView(m_watchTableModel);
+    m_watchTableView->setModel(m_watchTableModel);
+    WatchTableHeaderView *header = new WatchTableHeaderView(m_watchTableModel);
+    m_watchTableView->setHorizontalHeader(header);
+
+    connect(m_objTree, SIGNAL(currentObjectChanged(QmlDebugObjectReference)),
+            m_propertiesView, SLOT(reload(QmlDebugObjectReference)));
+    connect(m_objTree, SIGNAL(expressionWatchRequested(QmlDebugObjectReference,QString)),
+            m_watchTableModel, SLOT(expressionWatchRequested(QmlDebugObjectReference,QString)));
+
+    connect(m_propertiesView, SIGNAL(activated(QmlDebugObjectReference,QmlDebugPropertyReference)),
+            m_watchTableModel, SLOT(togglePropertyWatch(QmlDebugObjectReference,QmlDebugPropertyReference)));
+
+    connect(m_watchTableModel, SIGNAL(watchCreated(QmlDebugWatch*)),
+            m_propertiesView, SLOT(watchCreated(QmlDebugWatch*)));
+
+    connect(m_watchTableView, SIGNAL(objectActivated(int)),
+            m_objTree, SLOT(setCurrentObject(int)));
+    
+    m_exprQueryWidget = new ExpressionQueryWidget(ExpressionQueryWidget::SeparateEntryMode, m_client);
+    connect(m_objTree, SIGNAL(currentObjectChanged(QmlDebugObjectReference)),
+            m_exprQueryWidget, SLOT(setCurrentObject(QmlDebugObjectReference)));
+    
+    QSplitter *propertiesTab = new QSplitter(Qt::Vertical);
+    propertiesTab->addWidget(m_propertiesView);
+    propertiesTab->addWidget(m_exprQueryWidget);
+    propertiesTab->setStretchFactor(0, 2);
+    propertiesTab->setStretchFactor(1, 1);
+    
+    m_tabs = new QTabWidget(this);
+    m_tabs->addTab(propertiesTab, tr("Properties"));
+    m_tabs->addTab(m_watchTableView, tr("Watched"));
+
+    splitter->addWidget(m_objTree);
+    splitter->addWidget(m_tabs);
+    splitter->setStretchFactor(1, 2);
+    layout->addWidget(splitter);
+}
+
+void EnginePane::engineSelected(int id)
+{
+    qWarning() << "Engine selected" << id;
+    queryContext(id);
+}
+
+void EnginePane::queryContext(int id)
+{
+    if (m_context) {
+        delete m_context;
+        m_context = 0;
+    }
+
+    m_context = m_client->queryRootContexts(QmlDebugEngineReference(id), this);
+    if (!m_context->isWaiting())
+        contextChanged();
+    else
+        QObject::connect(m_context, SIGNAL(stateChanged(QmlDebugQuery::State)),
+                         this, SLOT(contextChanged()));
+}
+
+void EnginePane::contextChanged()
+{
+    //dump(m_context->rootContext(), 0);
+
+    foreach (const QmlDebugObjectReference &object, m_context->rootContext().objects())
+        m_objTree->reload(object.debugId());
+
+    delete m_context; m_context = 0;
+}
+
+void EnginePane::refreshEngines()
+{
+    if (m_engines)
+        return;
+
+    m_engines = m_client->queryAvailableEngines(this);
+    if (!m_engines->isWaiting())
+        enginesChanged();
+    else
+        QObject::connect(m_engines, SIGNAL(stateChanged(QmlDebugQuery::State)), 
+                         this, SLOT(enginesChanged()));
+}
+
+void EnginePane::enginesChanged()
+{
+    qDeleteAll(m_engineItems);
+    m_engineItems.clear();
+
+    QList<QmlDebugEngineReference> engines = m_engines->engines();
+    delete m_engines; m_engines = 0;
+
+    if (engines.isEmpty())
+        qWarning("qmldebugger: no engines found!");
+
+    for (int ii = 0; ii < engines.count(); ++ii)
+        m_engineItems << new DebuggerEngineItem(engines.at(ii).name(),
+                                                engines.at(ii).debugId());
+
+    m_engineView->rootContext()->setContextProperty("engines", qVariantFromValue(&m_engineItems));
+
+    m_engineView->setVisible(m_engineItems.count() > 1);
+    if (m_engineItems.count() == 1)
+        engineSelected(qobject_cast<DebuggerEngineItem*>(m_engineItems.at(0))->engineId());
+}
+
+
+#include "engine.moc"
+
+QT_END_NAMESPACE
+
diff --git a/tools/qmldebugger/standalone/engine.h b/tools/qmldebugger/standalone/engine.h
new file mode 100644
index 0000000..f4c4275
--- /dev/null
+++ b/tools/qmldebugger/standalone/engine.h
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef ENGINE_H
+#define ENGINE_H
+
+#include <QWidget>
+#include <QtCore/qpointer.h>
+#include <QtDeclarative/qmlengine.h>
+#include <QtDeclarative/qmlcontext.h>
+#include <QtDeclarative/qmlview.h>
+#include <private/qmldebug_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class ObjectPropertiesView;
+class QmlDebugConnection;
+class QmlDebugPropertyReference;
+class QmlDebugWatch;
+class ObjectTree;
+class WatchTableModel;
+class WatchTableView;
+class ExpressionQueryWidget;
+
+class QTabWidget;
+
+class EnginePane : public QWidget
+{
+Q_OBJECT
+public:
+    EnginePane(QmlDebugConnection *, QWidget *parent = 0);
+
+public slots:
+    void refreshEngines();
+
+private slots:
+    void enginesChanged();
+
+    void queryContext(int);
+    void contextChanged();
+
+    void engineSelected(int);
+
+private:
+    QmlEngineDebug *m_client;
+    QmlDebugEnginesQuery *m_engines;
+    QmlDebugRootContextQuery *m_context;
+
+    ObjectTree *m_objTree;
+    QTabWidget *m_tabs;
+    WatchTableView *m_watchTableView;
+    WatchTableModel *m_watchTableModel;
+    ExpressionQueryWidget *m_exprQueryWidget;
+
+    QmlView *m_engineView;
+    QList<QObject *> m_engineItems;
+
+    ObjectPropertiesView *m_propertiesView;
+};
+
+QT_END_NAMESPACE
+
+#endif // ENGINE_H
+
diff --git a/tools/qmldebugger/standalone/engine.png b/tools/qmldebugger/standalone/engine.png
new file mode 100644
index 0000000..a0a8a04
--- /dev/null
+++ b/tools/qmldebugger/standalone/engine.png
diff --git a/tools/qmldebugger/standalone/engines.qml b/tools/qmldebugger/standalone/engines.qml
new file mode 100644
index 0000000..0b2b7ac
--- /dev/null
+++ b/tools/qmldebugger/standalone/engines.qml
@@ -0,0 +1,46 @@
+import Qt 4.6
+
+Item {
+    height: 100
+    id: root
+    signal engineClicked(int id)
+    signal refreshEngines()
+
+    Row {
+        anchors.fill: parent
+        Repeater {
+            model: engines
+            Item {
+                width: 100; height: 100;
+                Image { 
+                    id: engineIcon; 
+                    source: "qrc:/engine.png"
+                    anchors.horizontalCenter: parent.horizontalCenter
+                }
+                Text { 
+                    anchors.top: engineIcon.bottom; 
+                    text: modelData.name + "(" + modelData.engineId + ")"
+                    anchors.horizontalCenter: parent.horizontalCenter
+                }
+                MouseRegion {
+                    anchors.fill: parent
+                    onClicked: root.engineClicked(modelData.engineId);
+                }
+            }
+        }
+    }
+
+
+    Image { 
+        y: 15
+        source: "qrc:/refresh.png";
+        width: 75; 
+        height: 63; 
+        smooth: true 
+        anchors.right: parent.right
+        MouseRegion {
+            anchors.fill: parent
+            onClicked: root.refreshEngines()
+        }
+    }
+}
diff --git a/tools/qmldebugger/standalone/expressionquerywidget.cpp b/tools/qmldebugger/standalone/expressionquerywidget.cpp
new file mode 100644
index 0000000..cd59871
--- /dev/null
+++ b/tools/qmldebugger/standalone/expressionquerywidget.cpp
@@ -0,0 +1,276 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <QtCore/qdebug.h>
+
+#include <QtGui/qlabel.h>
+#include <QtGui/qtextedit.h>
+#include <QtGui/qlineedit.h>
+#include <QtGui/qpushbutton.h>
+#include <QtGui/qevent.h>
+#include <QtGui/qgroupbox.h>
+#include <QtGui/qtextobject.h>
+#include <QtGui/qlayout.h>
+
+#include "expressionquerywidget.h"
+
+ExpressionQueryWidget::ExpressionQueryWidget(Mode mode, QmlEngineDebug *client, QWidget *parent)
+    : QWidget(parent),
+      m_mode(mode),
+      m_client(client),
+      m_query(0),
+      m_textEdit(new QTextEdit),
+      m_lineEdit(0)
+{
+    m_prompt = QLatin1String(">> ");
+
+    QVBoxLayout *layout = new QVBoxLayout(this);
+    layout->setMargin(0);
+    layout->setSpacing(0);
+    layout->addWidget(m_textEdit);
+
+    updateTitle();
+
+    if (m_mode == SeparateEntryMode) {
+        m_lineEdit = new QLineEdit;
+        connect(m_lineEdit, SIGNAL(returnPressed()), SLOT(executeExpression()));
+        QHBoxLayout *hbox = new QHBoxLayout;
+        hbox->setMargin(5);
+        hbox->setSpacing(5);
+        hbox->addWidget(new QLabel(tr("Expression:")));
+        hbox->addWidget(m_lineEdit);
+        layout->addLayout(hbox);
+
+        m_textEdit->setReadOnly(true);
+        m_lineEdit->installEventFilter(this);
+    } else {
+        m_textEdit->installEventFilter(this);
+        appendPrompt();
+    }
+}
+
+void ExpressionQueryWidget::setEngineDebug(QmlEngineDebug *client)
+{
+    m_client = client;
+}
+
+void ExpressionQueryWidget::clear()
+{
+    m_textEdit->clear();
+    if (m_lineEdit)
+        m_lineEdit->clear();
+    if (m_mode == ShellMode)
+        appendPrompt();
+}
+
+void ExpressionQueryWidget::updateTitle()
+{
+    if (m_currObject.debugId() < 0) {
+        m_title = tr("Expression queries");
+    } else {
+        QString desc = QLatin1String("<")
+            + m_currObject.className() + QLatin1String(": ")
+            + (m_currObject.name().isEmpty() ? QLatin1String("<unnamed>") : m_currObject.name())
+            + QLatin1String(">");
+        m_title = tr("Expression queries (using context for %1)" , "Selected object").arg(desc);
+    }
+}
+
+void ExpressionQueryWidget::appendPrompt()
+{
+    m_textEdit->moveCursor(QTextCursor::End);
+
+    if (m_mode == SeparateEntryMode) {
+        m_textEdit->insertPlainText("\n");
+    } else {
+        m_textEdit->setTextColor(Qt::gray);
+        m_textEdit->append(m_prompt);
+    }
+}
+
+void ExpressionQueryWidget::setCurrentObject(const QmlDebugObjectReference &obj)
+{
+    m_currObject = obj;
+    updateTitle();
+}
+
+void ExpressionQueryWidget::checkCurrentContext()
+{
+    m_textEdit->moveCursor(QTextCursor::End);
+
+    if (m_currObject.debugId() != -1 && m_currObject.debugId() != m_objectAtLastFocus.debugId())
+        showCurrentContext();
+    m_objectAtLastFocus = m_currObject;
+}
+
+void ExpressionQueryWidget::showCurrentContext()
+{
+    if (m_mode == ShellMode) {
+        // clear the initial prompt
+        if (m_textEdit->document()->lineCount() == 1)
+            m_textEdit->clear();
+    }
+
+    m_textEdit->moveCursor(QTextCursor::End);
+    m_textEdit->setTextColor(Qt::darkGreen);
+    m_textEdit->append(m_currObject.className()
+            + QLatin1String(": ")
+            + (m_currObject.name().isEmpty() ? QLatin1String("<unnamed object>") : m_currObject.name()));
+    appendPrompt();
+}
+
+void ExpressionQueryWidget::executeExpression()
+{
+    if (!m_client)
+        return;
+        
+    if (m_mode == SeparateEntryMode)
+        m_expr = m_lineEdit->text().trimmed();
+    else
+        m_expr = m_expr.trimmed();
+
+    if (!m_expr.isEmpty() && m_currObject.debugId() != -1) {
+        if (m_query)
+            delete m_query;
+        m_query = m_client->queryExpressionResult(m_currObject.debugId(), m_expr, this);
+        if (!m_query->isWaiting())
+            showResult();
+        else
+            QObject::connect(m_query, SIGNAL(stateChanged(QmlDebugQuery::State)),
+                            this, SLOT(showResult()));
+
+        m_lastExpr = m_expr;
+        if (m_lineEdit)
+            m_lineEdit->clear();
+    }
+}
+
+void ExpressionQueryWidget::showResult()
+{
+    if (m_query) {
+        m_textEdit->moveCursor(QTextCursor::End);
+        QVariant value = m_query->result();
+        QString result;
+        
+        if (value.type() == QVariant::List || value.type() == QVariant::StringList) {
+            result = tr("<%1 items>", "%1 = number of items").arg(value.toList().count());
+        } else if (value.isNull()) {
+            result = QLatin1String("<no value>");
+        } else {
+            result = value.toString();
+        }
+
+        if (m_mode == SeparateEntryMode) {
+            m_textEdit->setTextColor(Qt::black);
+            m_textEdit->setFontWeight(QFont::Bold);
+            m_textEdit->insertPlainText(m_expr + " : ");
+            m_textEdit->setFontWeight(QFont::Normal);
+            m_textEdit->insertPlainText(result);
+        } else {
+            m_textEdit->setTextColor(Qt::darkGreen);
+            m_textEdit->insertPlainText(" => ");
+            m_textEdit->setTextColor(Qt::black);
+            m_textEdit->insertPlainText(result);
+        }
+        appendPrompt();
+        m_expr.clear();
+    }
+}
+
+bool ExpressionQueryWidget::eventFilter(QObject *obj, QEvent *event)
+{
+    if (obj == m_textEdit) {
+        switch (event->type()) {
+            case QEvent::KeyPress:
+            {
+                QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
+                int key = keyEvent->key();
+                if (key == Qt::Key_Return || key == Qt::Key_Enter) {
+                    executeExpression();
+                    return true;
+                } else if (key == Qt::Key_Backspace) {
+                    // ensure m_expr doesn't contain backspace characters
+                    QTextCursor cursor = m_textEdit->textCursor();
+                    bool atLastLine = !(cursor.block().next().isValid());
+                    if (!atLastLine)
+                        return true;
+                    if (cursor.columnNumber() <= m_prompt.count())
+                        return true;
+                    cursor.deletePreviousChar();
+                    m_expr = cursor.block().text().mid(m_prompt.count());
+                    return true;
+                } else {
+                    m_textEdit->moveCursor(QTextCursor::End);
+                    m_textEdit->setTextColor(Qt::black);
+                    m_expr += keyEvent->text();
+                }
+                break;
+            }
+            case QEvent::FocusIn:
+                checkCurrentContext();
+                m_textEdit->moveCursor(QTextCursor::End);
+                break;
+            default:
+                break;
+        }
+    } else if (obj == m_lineEdit) {
+        switch (event->type()) {
+            case QEvent::KeyPress:
+            {
+                QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
+                int key = keyEvent->key();
+                if (key == Qt::Key_Up && m_lineEdit->text() != m_lastExpr) {
+                    m_expr = m_lineEdit->text();
+                    if (!m_lastExpr.isEmpty())
+                        m_lineEdit->setText(m_lastExpr);
+                } else if (key == Qt::Key_Down) {
+                    m_lineEdit->setText(m_expr);
+                }
+                break;
+            }
+            case QEvent::FocusIn:
+                checkCurrentContext();
+                break;
+            default:
+                break;
+        }
+    }
+    return QWidget::eventFilter(obj, event);
+}
diff --git a/tools/qmldebugger/standalone/expressionquerywidget.h b/tools/qmldebugger/standalone/expressionquerywidget.h
new file mode 100644
index 0000000..8c224f8
--- /dev/null
+++ b/tools/qmldebugger/standalone/expressionquerywidget.h
@@ -0,0 +1,105 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef EXPRESSIONQUERYWIDGET_H
+#define EXPRESSIONQUERYWIDGET_H
+
+#include <QWidget>
+
+#include <private/qmldebug_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QGroupBox;
+class QTextEdit;
+class QLineEdit;
+class QPushButton;
+
+class ExpressionQueryWidget : public QWidget
+{
+    Q_OBJECT
+public:
+    enum Mode {
+        SeparateEntryMode,
+        ShellMode
+    };
+
+    ExpressionQueryWidget(Mode mode = SeparateEntryMode, QmlEngineDebug *client = 0, QWidget *parent = 0);
+    
+    void setEngineDebug(QmlEngineDebug *client);
+    void clear();
+
+protected:
+    bool eventFilter(QObject *obj, QEvent *event);
+
+public slots:
+    void setCurrentObject(const QmlDebugObjectReference &obj);
+
+private slots:
+    void executeExpression();
+    void showResult();
+
+private:
+    void appendPrompt();
+    void checkCurrentContext();
+    void showCurrentContext();
+    void updateTitle();
+
+    Mode m_mode;
+
+    QmlEngineDebug *m_client;
+    QmlDebugExpressionQuery *m_query;
+    QTextEdit *m_textEdit;
+    QLineEdit *m_lineEdit;
+    QPushButton *m_button;
+    QString m_prompt;
+    QString m_expr;
+    QString m_lastExpr;
+
+    QString m_title;
+
+    QmlDebugObjectReference m_currObject;
+    QmlDebugObjectReference m_objectAtLastFocus;
+};
+
+QT_END_NAMESPACE
+
+#endif
+
diff --git a/tools/qmldebugger/standalone/main.cpp b/tools/qmldebugger/standalone/main.cpp
new file mode 100644
index 0000000..715837e
--- /dev/null
+++ b/tools/qmldebugger/standalone/main.cpp
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <QtGui/qapplication.h>
+
+#include "qmldebugger.h"
+
+int main(int argc, char ** argv)
+{
+    QApplication app(argc, argv);
+    app.setApplicationName("QtQmlDebugger");
+    app.setOrganizationName("Nokia");
+    app.setOrganizationDomain("nokia.com");    
+
+    QStringList args = app.arguments();
+
+    QmlDebugger win;
+    if (args.contains("--engine"))
+        win.showEngineTab();
+
+    for (int i=0; i<args.count(); i++) {
+        if (!args[i].contains(':'))
+            continue;
+        QStringList hostAndPort = args[i].split(':');
+        bool ok = false;
+        quint16 port = hostAndPort.value(1).toInt(&ok);
+        if (ok) {
+            qWarning() << "qmldebugger connecting to"
+                    << hostAndPort[0] << port << "...";
+            win.setHost(hostAndPort[0]);
+            win.setPort(port);
+            win.connectToHost();
+            break;
+        }
+    }
+
+    win.show();
+
+    return app.exec();
+}
diff --git a/tools/qmldebugger/standalone/objectpropertiesview.cpp b/tools/qmldebugger/standalone/objectpropertiesview.cpp
new file mode 100644
index 0000000..3a8d8c8
--- /dev/null
+++ b/tools/qmldebugger/standalone/objectpropertiesview.cpp
@@ -0,0 +1,274 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <QtCore/qdebug.h>
+
+#include <QtGui/qtreewidget.h>
+#include <QtGui/qlayout.h>
+#include <QtGui/qheaderview.h>
+
+#include <private/qmldebugservice_p.h>
+#include <private/qmldebug_p.h>
+#include <private/qmldebugclient_p.h>
+
+#include "objectpropertiesview.h"
+
+QT_BEGIN_NAMESPACE
+
+class PropertiesViewItem : public QObject, public QTreeWidgetItem
+{
+    Q_OBJECT
+public:
+    enum Type {
+        BindingType,
+        OtherType
+    };
+    
+    PropertiesViewItem(QTreeWidget *widget, Type type = OtherType);
+    PropertiesViewItem(QTreeWidgetItem *parent, Type type = OtherType);
+
+    QmlDebugPropertyReference property;
+    Type type;
+};
+
+PropertiesViewItem::PropertiesViewItem(QTreeWidget *widget, Type type)
+    : QTreeWidgetItem(widget), type(type)
+{
+}
+
+PropertiesViewItem::PropertiesViewItem(QTreeWidgetItem *parent, Type type)
+    : QTreeWidgetItem(parent), type(type)
+{
+}
+
+ObjectPropertiesView::ObjectPropertiesView(QmlEngineDebug *client, QWidget *parent)
+    : QWidget(parent),
+      m_client(client),
+      m_query(0),
+      m_watch(0)
+{
+    QVBoxLayout *layout = new QVBoxLayout;
+    layout->setContentsMargins(0, 0, 0, 0);
+    layout->setSpacing(0);
+    setLayout(layout);
+
+    m_tree = new QTreeWidget(this);
+    m_tree->setAlternatingRowColors(true);
+    m_tree->setExpandsOnDoubleClick(false);
+    m_tree->setHeaderLabels(QStringList()
+            << tr("Name") << tr("Value") << tr("Type"));
+    QObject::connect(m_tree, SIGNAL(itemActivated(QTreeWidgetItem *, int)),
+                     this, SLOT(itemActivated(QTreeWidgetItem *)));
+
+    m_tree->setColumnCount(3);
+    m_tree->header()->setDefaultSectionSize(150);
+
+    layout->addWidget(m_tree);
+}
+
+void ObjectPropertiesView::setEngineDebug(QmlEngineDebug *client)
+{
+    m_client = client;
+}
+
+void ObjectPropertiesView::clear()
+{
+    setObject(QmlDebugObjectReference());
+}
+
+void ObjectPropertiesView::reload(const QmlDebugObjectReference &obj)
+{
+    if (!m_client)
+        return;
+    if (m_query)
+        delete m_query;
+
+    m_query = m_client->queryObjectRecursive(obj, this);
+    if (!m_query->isWaiting())
+        queryFinished();
+    else
+        QObject::connect(m_query, SIGNAL(stateChanged(QmlDebugQuery::State)),
+                         this, SLOT(queryFinished()));
+}
+
+void ObjectPropertiesView::queryFinished()
+{
+    if (!m_client || !m_query)
+        return;
+
+    QmlDebugObjectReference obj = m_query->object();
+
+    QmlDebugWatch *watch = m_client->addWatch(obj, this);
+    if (watch->state() == QmlDebugWatch::Dead) {
+        delete watch;
+        watch = 0;
+    } else {
+        if (m_watch) {
+            m_client->removeWatch(m_watch);
+            delete m_watch;
+        }
+        m_watch = watch;
+        QObject::connect(watch, SIGNAL(valueChanged(QByteArray,QVariant)),
+                        this, SLOT(valueChanged(QByteArray,QVariant)));
+    }
+
+    delete m_query;
+    m_query = 0;
+
+    setObject(obj);
+}
+
+void ObjectPropertiesView::setPropertyValue(PropertiesViewItem *item, const QVariant &value, bool makeGray)
+{
+    if (value.type() == QVariant::List || value.type() == QVariant::StringList) {
+        PropertiesViewItem *bindingItem = static_cast<PropertiesViewItem*>(item->takeChild(item->childCount() - 1));
+        if (bindingItem && bindingItem->type != PropertiesViewItem::BindingType) {
+            delete bindingItem;
+            bindingItem = 0;
+        }    
+            
+        qDeleteAll(item->takeChildren());
+        
+        QVariantList variants = value.toList();
+        item->setText(1, tr("<%1 items>", "%1 = number of items").arg(variants.count()));
+        item->setText(2, QString::fromUtf8(value.typeName()));
+        
+        PropertiesViewItem *child;
+        for (int i=0; i<variants.count(); i++) {
+            child = new PropertiesViewItem(item);
+            setPropertyValue(child, variants[i], makeGray);
+        }
+        
+        if (bindingItem)
+            item->addChild(bindingItem);
+
+        item->setExpanded(false);
+    } else {
+        item->setText(1, (value.isNull() ? QLatin1String("<no value>") : value.toString()));
+        item->setExpanded(true);
+    }
+    
+    if (makeGray) {
+        for (int i=0; i<m_tree->columnCount(); i++)
+            item->setForeground(i, Qt::gray);
+    }    
+}
+
+void ObjectPropertiesView::setObject(const QmlDebugObjectReference &object)
+{
+    m_object = object;
+    m_tree->clear();
+
+    QList<QmlDebugPropertyReference> properties = object.properties();
+    for (int i=0; i<properties.count(); i++) {
+        const QmlDebugPropertyReference &p = properties[i];
+
+        PropertiesViewItem *item = new PropertiesViewItem(m_tree);
+        item->property = p;
+
+        item->setText(0, p.name());
+        item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
+        
+        setPropertyValue(item, p.value(), !p.hasNotifySignal());
+        item->setText(2, p.valueTypeName());
+
+        // binding is set after property value to ensure it is added to the end of the
+        // list, if the value is a list
+        if (!p.binding().isEmpty()) {
+            PropertiesViewItem *binding = new PropertiesViewItem(item, PropertiesViewItem::BindingType);
+            binding->setText(1, p.binding());
+            binding->setForeground(1, Qt::darkGreen);
+        }
+    }
+}
+
+void ObjectPropertiesView::watchCreated(QmlDebugWatch *watch)
+{
+    if (watch->objectDebugId() == m_object.debugId()
+            && qobject_cast<QmlDebugPropertyWatch*>(watch)) {
+        connect(watch, SIGNAL(stateChanged(QmlDebugWatch::State)), SLOT(watchStateChanged()));
+        setWatched(qobject_cast<QmlDebugPropertyWatch*>(watch)->name(), true);
+    }
+}
+
+void ObjectPropertiesView::watchStateChanged()
+{
+    QmlDebugWatch *watch = qobject_cast<QmlDebugWatch*>(sender());
+
+    if (watch->objectDebugId() == m_object.debugId()
+            && qobject_cast<QmlDebugPropertyWatch*>(watch)
+            && watch->state() == QmlDebugWatch::Inactive) {
+        setWatched(qobject_cast<QmlDebugPropertyWatch*>(watch)->name(), false);
+    }
+}
+
+void ObjectPropertiesView::setWatched(const QString &property, bool watched)
+{
+    for (int i=0; i<m_tree->topLevelItemCount(); i++) {
+        PropertiesViewItem *item = static_cast<PropertiesViewItem *>(m_tree->topLevelItem(i));
+        if (item->property.name() == property && item->property.hasNotifySignal()) {
+            QFont font = m_tree->font();
+            font.setBold(watched);
+            item->setFont(0, font);
+        }
+    }
+}
+
+void ObjectPropertiesView::valueChanged(const QByteArray &name, const QVariant &value)
+{
+    for (int i=0; i<m_tree->topLevelItemCount(); i++) {
+        PropertiesViewItem *item = static_cast<PropertiesViewItem *>(m_tree->topLevelItem(i));
+        if (item->property.name() == name) {
+            setPropertyValue(item, value, !item->property.hasNotifySignal());
+            return;
+        }
+    }
+}
+
+void ObjectPropertiesView::itemActivated(QTreeWidgetItem *i)
+{
+    PropertiesViewItem *item = static_cast<PropertiesViewItem *>(i);
+    if (!item->property.name().isEmpty())
+        emit activated(m_object, item->property);
+}
+
+QT_END_NAMESPACE
+
+#include "objectpropertiesview.moc"
diff --git a/tools/qmldebugger/standalone/objectpropertiesview.h b/tools/qmldebugger/standalone/objectpropertiesview.h
new file mode 100644
index 0000000..43413dc
--- /dev/null
+++ b/tools/qmldebugger/standalone/objectpropertiesview.h
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef PROPERTIESTABLEMODEL_H
+#define PROPERTIESTABLEMODEL_H
+
+#include <private/qmldebug_p.h>
+
+#include <QtGui/qwidget.h>
+
+QT_BEGIN_NAMESPACE
+
+class QTreeWidget;
+class QTreeWidgetItem;
+class QmlDebugConnection;
+class PropertiesViewItem;
+
+class ObjectPropertiesView : public QWidget
+{
+    Q_OBJECT
+public:
+    ObjectPropertiesView(QmlEngineDebug *client = 0, QWidget *parent = 0);
+
+    void setEngineDebug(QmlEngineDebug *client);
+    void clear();
+    
+signals:
+    void activated(const QmlDebugObjectReference &, const QmlDebugPropertyReference &);
+
+public slots:
+    void reload(const QmlDebugObjectReference &);
+    void watchCreated(QmlDebugWatch *);
+
+private slots:
+    void queryFinished();
+    void watchStateChanged();
+    void valueChanged(const QByteArray &name, const QVariant &value);
+    void itemActivated(QTreeWidgetItem *i);
+
+private:
+    void setObject(const QmlDebugObjectReference &object);
+    void setWatched(const QString &property, bool watched);
+    void setPropertyValue(PropertiesViewItem *item, const QVariant &value, bool makeGray);
+
+    QmlEngineDebug *m_client;
+    QmlDebugObjectQuery *m_query;
+    QmlDebugWatch *m_watch;
+
+    QTreeWidget *m_tree;
+    QmlDebugObjectReference m_object;
+};
+
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/tools/qmldebugger/standalone/objecttree.cpp b/tools/qmldebugger/standalone/objecttree.cpp
new file mode 100644
index 0000000..cf467f2
--- /dev/null
+++ b/tools/qmldebugger/standalone/objecttree.cpp
@@ -0,0 +1,231 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <QtGui/qevent.h>
+#include <QtGui/qmenu.h>
+#include <QtGui/qaction.h>
+
+#include <QInputDialog>
+
+#include <private/qmldebugservice_p.h>
+#include <private/qmldebug_p.h>
+#include <private/qmldebugclient_p.h>
+
+#include "objecttree.h"
+
+Q_DECLARE_METATYPE(QmlDebugObjectReference)
+
+ObjectTree::ObjectTree(QmlEngineDebug *client, QWidget *parent)
+    : QTreeWidget(parent),
+      m_client(client),
+      m_query(0)
+{
+    setHeaderHidden(true);
+    setMinimumWidth(250);
+    setExpandsOnDoubleClick(false);
+
+    connect(this, SIGNAL(currentItemChanged(QTreeWidgetItem *, QTreeWidgetItem *)),
+            SLOT(currentItemChanged(QTreeWidgetItem *)));
+    connect(this, SIGNAL(itemActivated(QTreeWidgetItem *, int)),
+            SLOT(activated(QTreeWidgetItem *)));            
+}
+
+void ObjectTree::setEngineDebug(QmlEngineDebug *client)
+{
+    m_client = client;
+}
+
+void ObjectTree::reload(int objectDebugId)
+{
+    if (!m_client)
+        return;
+        
+    if (m_query) {
+        delete m_query;
+        m_query = 0;
+    }
+
+    m_query = m_client->queryObjectRecursive(QmlDebugObjectReference(objectDebugId), this);
+    if (!m_query->isWaiting())
+        objectFetched();
+    else
+        QObject::connect(m_query, SIGNAL(stateChanged(QmlDebugQuery::State)), 
+                         this, SLOT(objectFetched()));
+}
+
+void ObjectTree::setCurrentObject(int debugId)
+{
+    QTreeWidgetItem *item = findItemByObjectId(debugId);
+    if (item) {
+        setCurrentItem(item);
+        scrollToItem(item);
+        item->setExpanded(true);
+    }
+}
+
+void ObjectTree::objectFetched()
+{
+    dump(m_query->object(), 0);
+    buildTree(m_query->object(), 0);
+    setCurrentItem(topLevelItem(0));
+
+    delete m_query;
+    m_query = 0;
+}
+
+void ObjectTree::currentItemChanged(QTreeWidgetItem *item)
+{
+    if (!item)
+        return;
+
+    QmlDebugObjectReference obj = item->data(0, Qt::UserRole).value<QmlDebugObjectReference>();
+    if (obj.debugId() >= 0)
+        emit currentObjectChanged(obj);
+}
+
+void ObjectTree::activated(QTreeWidgetItem *item)
+{
+    if (!item)
+        return;
+
+    QmlDebugObjectReference obj = item->data(0, Qt::UserRole).value<QmlDebugObjectReference>();
+    if (obj.debugId() >= 0)
+        emit activated(obj);
+}
+
+void ObjectTree::buildTree(const QmlDebugObjectReference &obj, QTreeWidgetItem *parent)
+{
+    if (!parent)
+        clear();
+
+    QTreeWidgetItem *item = parent ? new QTreeWidgetItem(parent) : new QTreeWidgetItem(this);
+    item->setText(0, obj.className());
+    item->setData(0, Qt::UserRole, qVariantFromValue(obj));
+
+    if (parent && obj.contextDebugId() >= 0
+            && obj.contextDebugId() != parent->data(0, Qt::UserRole
+                    ).value<QmlDebugObjectReference>().contextDebugId()) {
+        QmlDebugFileReference source = obj.source();
+        if (!source.url().isEmpty()) {
+            QString toolTipString = QLatin1String("URL: ") + source.url().toString();
+            item->setToolTip(0, toolTipString);
+        }
+        item->setForeground(0, QColor("orange"));
+    } else {
+        item->setExpanded(true);
+    }
+
+    if (obj.contextDebugId() < 0)
+        item->setForeground(0, Qt::lightGray);
+
+    for (int ii = 0; ii < obj.children().count(); ++ii)
+        buildTree(obj.children().at(ii), item);
+}
+
+void ObjectTree::dump(const QmlDebugContextReference &ctxt, int ind)
+{
+    QByteArray indent(ind * 4, ' ');
+    qWarning().nospace() << indent.constData() << ctxt.debugId() << " " 
+                         << qPrintable(ctxt.name());
+
+    for (int ii = 0; ii < ctxt.contexts().count(); ++ii)
+        dump(ctxt.contexts().at(ii), ind + 1);
+
+    for (int ii = 0; ii < ctxt.objects().count(); ++ii)
+        dump(ctxt.objects().at(ii), ind);
+}
+
+void ObjectTree::dump(const QmlDebugObjectReference &obj, int ind)
+{
+    QByteArray indent(ind * 4, ' ');
+    qWarning().nospace() << indent.constData() << qPrintable(obj.className())
+                         << " " << qPrintable(obj.name()) << " " 
+                         << obj.debugId();
+
+    for (int ii = 0; ii < obj.children().count(); ++ii)
+        dump(obj.children().at(ii), ind + 1);
+}
+
+QTreeWidgetItem *ObjectTree::findItemByObjectId(int debugId) const
+{
+    for (int i=0; i<topLevelItemCount(); i++) {
+        QTreeWidgetItem *item = findItem(topLevelItem(i), debugId);
+        if (item)
+            return item;
+    }
+
+    return 0;
+}
+
+QTreeWidgetItem *ObjectTree::findItem(QTreeWidgetItem *item, int debugId) const
+{
+    if (item->data(0, Qt::UserRole).value<QmlDebugObjectReference>().debugId() == debugId)
+        return item;
+
+    QTreeWidgetItem *child;
+    for (int i=0; i<item->childCount(); i++) {
+        child = findItem(item->child(i), debugId);
+        if (child)
+            return child;
+    }
+
+    return 0;
+}
+
+void ObjectTree::mousePressEvent(QMouseEvent *me)
+{
+    QTreeWidget::mousePressEvent(me);
+    if (!currentItem())
+        return;
+    if(me->button()  == Qt::RightButton && me->type() == QEvent::MouseButtonPress) {
+        QAction action(tr("Add watch..."), 0);
+        QList<QAction *> actions;
+        actions << &action;
+        QmlDebugObjectReference obj =
+                currentItem()->data(0, Qt::UserRole).value<QmlDebugObjectReference>();
+        if (QMenu::exec(actions, me->globalPos())) {
+            bool ok = false;
+            QString watch = QInputDialog::getText(this, tr("Watch expression"),
+                    tr("Expression:"), QLineEdit::Normal, QString(), &ok);
+            if (ok && !watch.isEmpty()) 
+                emit expressionWatchRequested(obj, watch);
+        }
+    } 
+}
diff --git a/tools/qmldebugger/standalone/objecttree.h b/tools/qmldebugger/standalone/objecttree.h
new file mode 100644
index 0000000..c8d625c
--- /dev/null
+++ b/tools/qmldebugger/standalone/objecttree.h
@@ -0,0 +1,96 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef OBJECTTREE_H
+#define OBJECTTREE_H
+
+#include <QtGui/qtreewidget.h>
+
+QT_BEGIN_NAMESPACE
+
+class QTreeWidgetItem;
+
+class QmlEngineDebug;
+class QmlDebugObjectReference;
+class QmlDebugObjectQuery;
+class QmlDebugContextReference;
+class QmlDebugConnection;
+
+
+class ObjectTree : public QTreeWidget
+{
+    Q_OBJECT
+public:
+    ObjectTree(QmlEngineDebug *client = 0, QWidget *parent = 0);
+
+    void setEngineDebug(QmlEngineDebug *client);
+    
+signals:
+    void currentObjectChanged(const QmlDebugObjectReference &);
+    void activated(const QmlDebugObjectReference &);
+    void expressionWatchRequested(const QmlDebugObjectReference &, const QString &);
+
+public slots:
+    void reload(int objectDebugId);     // set the root object
+    void setCurrentObject(int debugId); // select an object in the tree
+
+protected:
+    virtual void mousePressEvent(QMouseEvent *);
+
+private slots:
+    void objectFetched();
+    void currentItemChanged(QTreeWidgetItem *);
+    void activated(QTreeWidgetItem *);
+
+private:
+    QTreeWidgetItem *findItemByObjectId(int debugId) const;
+    QTreeWidgetItem *findItem(QTreeWidgetItem *item, int debugId) const;
+    void dump(const QmlDebugContextReference &, int);
+    void dump(const QmlDebugObjectReference &, int);
+    void buildTree(const QmlDebugObjectReference &, QTreeWidgetItem *parent);
+
+    QmlEngineDebug *m_client;
+    QmlDebugObjectQuery *m_query;
+};
+
+QT_END_NAMESPACE
+
+
+#endif
diff --git a/tools/qmldebugger/standalone/qmldebugger.cpp b/tools/qmldebugger/standalone/qmldebugger.cpp
new file mode 100644
index 0000000..4d86377
--- /dev/null
+++ b/tools/qmldebugger/standalone/qmldebugger.cpp
@@ -0,0 +1,181 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <QtCore/qtimer.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qsettings.h>
+
+#include <QtGui/qlayout.h>
+#include <QtGui/qpushbutton.h>
+#include <QtGui/qlineedit.h>
+#include <QtGui/qtabwidget.h>
+#include <QtGui/qspinbox.h>
+#include <QtGui/qlabel.h>
+
+#include "canvasframerate.h"
+#include "engine.h"
+#include "qmldebugger.h"
+
+QmlDebugger::QmlDebugger(QWidget *parent)
+: QWidget(parent)
+{
+    QVBoxLayout *layout = new QVBoxLayout;
+    setLayout(layout);
+
+    QHBoxLayout *connectLayout = new QHBoxLayout;
+    layout->addLayout(connectLayout);
+    connectLayout->addStretch(2);
+
+    m_connectionState = new QLabel(this);
+    connectLayout->addWidget(m_connectionState);
+    m_host = new QLineEdit(this);
+    connectLayout->addWidget(m_host);
+    m_port = new QSpinBox(this);
+    m_port->setMinimum(1024);
+    m_port->setMaximum(20000);
+    connectLayout->addWidget(m_port);
+    m_connectButton = new QPushButton(tr("Connect"), this);
+    QObject::connect(m_connectButton, SIGNAL(clicked()), 
+                     this, SLOT(connectToHost()));
+    connectLayout->addWidget(m_connectButton);
+    m_disconnectButton = new QPushButton(tr("Disconnect"), this);
+    QObject::connect(m_disconnectButton, SIGNAL(clicked()), 
+                     this, SLOT(disconnectFromHost()));
+    m_disconnectButton->setEnabled(false);
+    connectLayout->addWidget(m_disconnectButton);
+
+    m_tabs = new QTabWidget(this);
+    layout->addWidget(m_tabs);
+
+    CanvasFrameRate *cfr = new CanvasFrameRate(this);
+    cfr->reset(&client);
+    cfr->setSizeHint(QSize(800, 600));
+    m_tabs->addTab(cfr, tr("Frame Rate"));
+
+    m_enginePane = new EnginePane(&client, this);
+    m_tabs->addTab(m_enginePane, tr("QML Engine"));
+
+    QObject::connect(&client, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
+                     this, SLOT(connectionStateChanged()));
+    connectionStateChanged();
+
+    QObject::connect(&client, SIGNAL(error(QAbstractSocket::SocketError)),
+                     this, SLOT(connectionError(QAbstractSocket::SocketError)));
+
+    QSettings settings;
+    m_host->setText(settings.value("Host", "127.0.0.1").toString());
+    m_port->setValue(settings.value("Port", 3768).toInt());
+    
+    connectToHost();
+}
+
+void QmlDebugger::setHost(const QString &host)
+{
+    m_host->setText(host);
+}
+
+void QmlDebugger::setPort(quint16 port)
+{
+    m_port->setValue(port);
+}
+
+void QmlDebugger::showEngineTab()
+{
+    m_tabs->setCurrentWidget(m_enginePane);
+}
+
+void QmlDebugger::closeEvent(QCloseEvent *event)
+{
+    QSettings settings;
+    settings.setValue("Host", m_host->text());
+    settings.setValue("Port", m_port->value());
+
+    QWidget::closeEvent(event);
+}
+
+void QmlDebugger::connectionStateChanged()
+{
+    switch (client.state()) {
+    default:
+    case QAbstractSocket::UnconnectedState:
+        m_connectionState->setText(tr("Disconnected"));
+        m_connectButton->setEnabled(true);
+        m_disconnectButton->setEnabled(false);
+        break;
+    case QAbstractSocket::HostLookupState:
+        m_connectionState->setText(tr("Resolving"));
+        m_connectButton->setEnabled(false);
+        m_disconnectButton->setEnabled(true);
+        break;
+    case QAbstractSocket::ConnectingState:
+        m_connectionState->setText(tr("Connecting"));
+        m_connectButton->setEnabled(false);
+        m_disconnectButton->setEnabled(true);
+        break;
+    case QAbstractSocket::ConnectedState:
+        m_connectionState->setText(tr("Connected"));
+        m_connectButton->setEnabled(false);
+        m_disconnectButton->setEnabled(true);
+
+        QTimer::singleShot(0, m_enginePane, SLOT(refreshEngines()));
+        break;
+    case QAbstractSocket::ClosingState:
+        m_connectionState->setText(tr("Closing"));
+        m_connectButton->setEnabled(false);
+        m_disconnectButton->setEnabled(false);
+        break;
+    }
+}
+
+void QmlDebugger::connectionError(QAbstractSocket::SocketError socketError)
+{
+    qWarning() << "qmldebugger cannot connect:" << socketError
+            << client.errorString();
+}
+
+void QmlDebugger::connectToHost()
+{
+    client.connectToHost(m_host->text(), m_port->value());
+}
+
+void QmlDebugger::disconnectFromHost()
+{
+    client.disconnectFromHost();
+}
diff --git a/tools/qmldebugger/standalone/qmldebugger.h b/tools/qmldebugger/standalone/qmldebugger.h
new file mode 100644
index 0000000..da95ef9
--- /dev/null
+++ b/tools/qmldebugger/standalone/qmldebugger.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef QMLDEBUGGER_H
+#define QMLDEBUGGER_H
+
+#include <private/qmldebugclient_p.h>
+#include <QtNetwork/qtcpsocket.h>
+#include <QtGui/qwidget.h>
+
+class QLabel;
+class QLineEdit;
+class QSpinBox;
+class QPushButton;
+class QTabWidget;
+
+class EnginePane;
+
+class QmlDebugger : public QWidget
+{
+    Q_OBJECT
+public:
+    QmlDebugger(QWidget * = 0);
+
+    void setHost(const QString &host);
+    void setPort(quint16 port);
+    void showEngineTab();
+
+public slots:
+    void connectToHost();
+    void disconnectFromHost();
+
+protected:
+    void closeEvent(QCloseEvent *);
+    
+private slots:
+    void connectionStateChanged();
+    void connectionError(QAbstractSocket::SocketError socketError);
+
+private:
+    QmlDebugConnection client;
+
+    QLabel *m_connectionState;
+    QLineEdit *m_host;
+    QSpinBox *m_port;
+    QPushButton *m_connectButton;
+    QPushButton *m_disconnectButton;
+
+    EnginePane *m_enginePane;
+    QTabWidget *m_tabs;
+};
+
+#endif
diff --git a/tools/qmldebugger/standalone/qmldebugger.pri b/tools/qmldebugger/standalone/qmldebugger.pri
new file mode 100644
index 0000000..ede7d31
--- /dev/null
+++ b/tools/qmldebugger/standalone/qmldebugger.pri
@@ -0,0 +1,18 @@
+QT += network declarative
+contains(QT_CONFIG, opengles2)|contains(QT_CONFIG, opengles1): QT += opengl
+
+INCLUDEPATH += ../../../src/declarative/debugger
+
+# Input
+HEADERS += $$PWD/canvasframerate.h \
+           $$PWD/watchtable.h \
+           $$PWD/objecttree.h \
+           $$PWD/objectpropertiesview.h \
+           $$PWD/expressionquerywidget.h
+
+SOURCES += $$PWD/canvasframerate.cpp \
+           $$PWD/watchtable.cpp \
+           $$PWD/objecttree.cpp \
+           $$PWD/objectpropertiesview.cpp \
+           $$PWD/expressionquerywidget.cpp
+
diff --git a/tools/qmldebugger/standalone/qmldebugger.qrc b/tools/qmldebugger/standalone/qmldebugger.qrc
new file mode 100644
index 0000000..cb53ad5
--- /dev/null
+++ b/tools/qmldebugger/standalone/qmldebugger.qrc
@@ -0,0 +1,7 @@
+<RCC>
+    <qresource prefix="/">
+        <file>engines.qml</file>
+        <file>engine.png</file>
+        <file>refresh.png</file>
+    </qresource>
+</RCC>
diff --git a/tools/qmldebugger/standalone/refresh.png b/tools/qmldebugger/standalone/refresh.png
new file mode 100644
index 0000000..8befc80
--- /dev/null
+++ b/tools/qmldebugger/standalone/refresh.png
diff --git a/tools/qmldebugger/standalone/standalone.pro b/tools/qmldebugger/standalone/standalone.pro
new file mode 100644
index 0000000..72d051f
--- /dev/null
+++ b/tools/qmldebugger/standalone/standalone.pro
@@ -0,0 +1,19 @@
+DESTDIR = ../../../bin
+TARGET = qmldebugger
+
+include(qmldebugger.pri)
+
+HEADERS += $$PWD/qmldebugger.h \
+           $$PWD/engine.h
+
+SOURCES += $$PWD/qmldebugger.cpp \
+           $$PWD/engine.cpp \
+           $$PWD/main.cpp 
+
+RESOURCES += $$PWD/qmldebugger.qrc
+OTHER_FILES += $$PWD/engines.qml
+
+target.path=$$[QT_INSTALL_BINS]
+INSTALLS += target
+
+CONFIG += console
diff --git a/tools/qmldebugger/standalone/watchtable.cpp b/tools/qmldebugger/standalone/watchtable.cpp
new file mode 100644
index 0000000..0e73de5
--- /dev/null
+++ b/tools/qmldebugger/standalone/watchtable.cpp
@@ -0,0 +1,366 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include "watchtable.h"
+
+#include <QtCore/qdebug.h>
+#include <QtGui/qevent.h>
+#include <QtGui/qaction.h>
+#include <QtGui/qmenu.h>
+
+#include <private/qmldebug_p.h>
+#include <QtDeclarative/qmlmetatype.h>
+
+QT_BEGIN_NAMESPACE
+
+
+WatchTableModel::WatchTableModel(QmlEngineDebug *client, QObject *parent)
+    : QAbstractTableModel(parent),
+      m_client(client)
+{
+}
+
+WatchTableModel::~WatchTableModel()
+{    
+    for (int i=0; i<m_columns.count(); i++)
+        delete m_columns[i].watch;
+}
+
+void WatchTableModel::setEngineDebug(QmlEngineDebug *client)
+{
+    m_client = client;
+}
+
+void WatchTableModel::addWatch(QmlDebugWatch *watch, const QString &title)
+{
+    QString property;
+    if (qobject_cast<QmlDebugPropertyWatch *>(watch))
+        property = qobject_cast<QmlDebugPropertyWatch *>(watch)->name();
+
+    connect(watch, SIGNAL(valueChanged(QByteArray,QVariant)),
+            SLOT(watchedValueChanged(QByteArray,QVariant)));
+
+    connect(watch, SIGNAL(stateChanged(QmlDebugWatch::State)), SLOT(watchStateChanged()));
+
+    int col = columnCount(QModelIndex());
+    beginInsertColumns(QModelIndex(), col, col);
+
+    WatchedEntity e;
+    e.title = title;
+    e.hasFirstValue = false;
+    e.property = property;
+    e.watch = watch;
+    m_columns.append(e);
+
+    endInsertColumns();
+}
+
+void WatchTableModel::removeWatch(QmlDebugWatch *watch)
+{
+    int column = columnForWatch(watch);
+    if (column == -1)
+        return;
+
+    WatchedEntity entity = m_columns.takeAt(column);
+
+    for (QList<Value>::Iterator iter = m_values.begin(); iter != m_values.end();) {
+        if (iter->column == column) {
+            iter = m_values.erase(iter);
+        } else {
+            if(iter->column > column)
+                --iter->column;
+            ++iter;
+        }
+    }
+
+    reset();
+}
+
+void WatchTableModel::updateWatch(QmlDebugWatch *watch, const QVariant &value)
+{
+    int column = columnForWatch(watch);
+    if (column == -1)
+        return;
+
+    addValue(column, value);
+
+    if (!m_columns[column].hasFirstValue) {
+        m_columns[column].hasFirstValue = true;
+        m_values[m_values.count() - 1].first = true;
+    }
+}
+
+QmlDebugWatch *WatchTableModel::findWatch(int column) const
+{
+    if (column < m_columns.count())
+        return m_columns.at(column).watch;
+    return 0;
+}
+
+QmlDebugWatch *WatchTableModel::findWatch(int objectDebugId, const QString &property) const
+{
+    for (int i=0; i<m_columns.count(); i++) {
+        if (m_columns[i].watch->objectDebugId() == objectDebugId
+                && m_columns[i].property == property) {
+            return m_columns[i].watch;
+        }
+    }
+    return 0;
+}
+
+int WatchTableModel::rowCount(const QModelIndex &) const
+{
+    return m_values.count();
+}
+
+int WatchTableModel::columnCount(const QModelIndex &) const
+{
+    return m_columns.count();
+}
+
+QVariant WatchTableModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    if (orientation == Qt::Horizontal) {
+        if (section < m_columns.count() && role == Qt::DisplayRole)
+            return m_columns.at(section).title;
+    } else {
+        if (role == Qt::DisplayRole)
+            return section + 1;
+    }
+    return QVariant();
+}
+
+QVariant WatchTableModel::data(const QModelIndex &idx, int role) const
+{
+    if (m_values.at(idx.row()).column == idx.column()) {
+        if (role == Qt::DisplayRole) {
+            const QVariant &value = m_values.at(idx.row()).variant;
+            QString str = value.toString();
+
+            if (str.isEmpty() && QmlMetaType::isObject(value.userType())) {
+                QObject *o = QmlMetaType::toQObject(value);
+                if(o) {
+                    QString objectName = o->objectName();
+                    if(objectName.isEmpty())
+                        objectName = QLatin1String("<unnamed>");
+                    str = QLatin1String(o->metaObject()->className()) +
+                          QLatin1String(": ") + objectName;
+                }
+            }
+
+            if(str.isEmpty()) {
+                QDebug d(&str);
+                d << value;
+            }
+            return QVariant(str);
+        } else if(role == Qt::BackgroundRole) {
+            if(m_values.at(idx.row()).first)
+                return QColor(Qt::green);
+            else
+                return QVariant();
+        } else {
+            return QVariant();
+        }
+    } else {
+        return QVariant();
+    }
+}
+
+void WatchTableModel::watchStateChanged()
+{
+    QmlDebugWatch *watch = qobject_cast<QmlDebugWatch*>(sender());
+
+    if (watch && watch->state() == QmlDebugWatch::Inactive) {
+        removeWatch(watch);
+        watch->deleteLater();
+    }
+}
+
+int WatchTableModel::columnForWatch(QmlDebugWatch *watch) const
+{
+    for (int i=0; i<m_columns.count(); i++) {
+        if (m_columns.at(i).watch == watch)
+            return i;
+    }
+    return -1;
+}
+
+void WatchTableModel::addValue(int column, const QVariant &value)
+{
+    int row = columnCount(QModelIndex());
+    beginInsertRows(QModelIndex(), row, row);
+
+    Value v;
+    v.column = column;
+    v.variant = value;
+    v.first = false;
+    m_values.append(v);
+
+    endInsertRows();
+}
+
+void WatchTableModel::togglePropertyWatch(const QmlDebugObjectReference &object, const QmlDebugPropertyReference &property)
+{
+    if (!m_client || !property.hasNotifySignal())
+        return;
+
+    QmlDebugWatch *watch = findWatch(object.debugId(), property.name());
+    if (watch) {
+        // watch will be deleted in watchStateChanged()
+        m_client->removeWatch(watch);
+        return;
+    }
+
+    watch = m_client->addWatch(property, this);
+    if (watch->state() == QmlDebugWatch::Dead) {
+        delete watch;
+        watch = 0;
+    } else {
+        QString desc = property.name()
+                + QLatin1String(" on\n")
+                + object.className()
+                + QLatin1String(":\n")
+                + (object.name().isEmpty() ? QLatin1String("<unnamed object>") : object.name());
+        addWatch(watch, desc);
+        emit watchCreated(watch);
+    }
+}
+
+void WatchTableModel::watchedValueChanged(const QByteArray &propertyName, const QVariant &value)
+{
+    Q_UNUSED(propertyName);
+    QmlDebugWatch *watch = qobject_cast<QmlDebugWatch*>(sender());
+    if (watch)
+        updateWatch(watch, value);
+}
+
+void WatchTableModel::expressionWatchRequested(const QmlDebugObjectReference &obj, const QString &expr)
+{
+    if (!m_client)
+        return;
+        
+    QmlDebugWatch *watch = m_client->addWatch(obj, expr, this);
+
+    if (watch->state() == QmlDebugWatch::Dead) {
+        delete watch;
+        watch = 0;
+    } else {
+        addWatch(watch, expr);
+        emit watchCreated(watch);
+    }
+}
+
+void WatchTableModel::removeWatchAt(int column)
+{
+    if (!m_client)
+        return;
+        
+    QmlDebugWatch *watch = findWatch(column);
+    if (watch) {
+        m_client->removeWatch(watch);
+        delete watch;
+        watch = 0;
+    }
+}
+
+void WatchTableModel::removeAllWatches()
+{
+    for (int i=0; i<m_columns.count(); i++) {
+        if (m_client)
+            m_client->removeWatch(m_columns[i].watch);
+        else    
+            delete m_columns[i].watch;
+    }
+    m_columns.clear();
+    m_values.clear();
+    reset();
+}
+
+//----------------------------------------------
+
+WatchTableHeaderView::WatchTableHeaderView(WatchTableModel *model, QWidget *parent)
+    : QHeaderView(Qt::Horizontal, parent),
+      m_model(model)
+{
+    setClickable(true);
+}
+
+void WatchTableHeaderView::mousePressEvent(QMouseEvent *me)
+{
+    QHeaderView::mousePressEvent(me);
+
+    if (me->button() == Qt::RightButton && me->type() == QEvent::MouseButtonPress) {
+        int col = logicalIndexAt(me->pos());
+        if (col >= 0) {
+            QAction action(tr("Stop watching"), 0);
+            QList<QAction *> actions;
+            actions << &action;
+            if (QMenu::exec(actions, me->globalPos()))
+                m_model->removeWatchAt(col);
+        }
+    } 
+}
+
+
+//----------------------------------------------
+
+WatchTableView::WatchTableView(WatchTableModel *model, QWidget *parent)
+    : QTableView(parent),
+      m_model(model)
+{
+    setAlternatingRowColors(true);
+    connect(model, SIGNAL(watchCreated(QmlDebugWatch*)), SLOT(watchCreated(QmlDebugWatch*)));
+    connect(this, SIGNAL(activated(QModelIndex)), SLOT(indexActivated(QModelIndex)));
+}
+
+void WatchTableView::indexActivated(const QModelIndex &index)
+{
+    QmlDebugWatch *watch = m_model->findWatch(index.column());
+    if (watch)
+        emit objectActivated(watch->objectDebugId());
+}
+
+void WatchTableView::watchCreated(QmlDebugWatch *watch)
+{
+    int column = m_model->columnForWatch(watch);
+    resizeColumnToContents(column);
+}
+
+QT_END_NAMESPACE
diff --git a/tools/qmldebugger/standalone/watchtable.h b/tools/qmldebugger/standalone/watchtable.h
new file mode 100644
index 0000000..fd12d3d
--- /dev/null
+++ b/tools/qmldebugger/standalone/watchtable.h
@@ -0,0 +1,154 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt QML Debugger of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef WATCHTABLEMODEL_H
+#define WATCHTABLEMODEL_H
+
+#include <QtCore/qpointer.h>
+#include <QtCore/qlist.h>
+
+#include <QWidget>
+#include <QHeaderView>
+#include <QAbstractTableModel>
+#include <QTableView>
+
+QT_BEGIN_NAMESPACE
+
+class QmlDebugWatch;
+class QmlEngineDebug;
+class QmlDebugConnection;
+class QmlDebugPropertyReference;
+class QmlDebugObjectReference;
+
+class WatchTableModel : public QAbstractTableModel
+{
+    Q_OBJECT
+public:
+    WatchTableModel(QmlEngineDebug *client = 0, QObject *parent = 0);
+    ~WatchTableModel();
+
+    void setEngineDebug(QmlEngineDebug *client);
+    
+    QmlDebugWatch *findWatch(int column) const;
+    int columnForWatch(QmlDebugWatch *watch) const;
+
+    void removeWatchAt(int column);
+    void removeAllWatches();
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const;
+    QVariant headerData(int section, Qt::Orientation orientation, int role) const;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+
+signals:
+    void watchCreated(QmlDebugWatch *watch);
+
+public slots:
+    void togglePropertyWatch(const QmlDebugObjectReference &obj, const QmlDebugPropertyReference &prop);
+    void expressionWatchRequested(const QmlDebugObjectReference &, const QString &);
+
+private slots:
+    void watchStateChanged();
+    void watchedValueChanged(const QByteArray &propertyName, const QVariant &value);
+
+private:
+    void addWatch(QmlDebugWatch *watch, const QString &title);
+    void removeWatch(QmlDebugWatch *watch);
+    void updateWatch(QmlDebugWatch *watch, const QVariant &value);
+
+    QmlDebugWatch *findWatch(int objectDebugId, const QString &property) const;
+
+    void addValue(int column, const QVariant &value);
+
+    struct WatchedEntity
+    {
+        QString title;
+        bool hasFirstValue;
+        QString property;
+        QPointer<QmlDebugWatch> watch;
+    };
+
+    struct Value {
+        int column;
+        QVariant variant;
+        bool first;
+    };
+
+    QmlEngineDebug *m_client;
+    QList<WatchedEntity> m_columns;
+    QList<Value> m_values;
+};
+
+
+class WatchTableHeaderView : public QHeaderView
+{
+    Q_OBJECT
+public:
+    WatchTableHeaderView(WatchTableModel *model, QWidget *parent = 0);
+
+protected:
+    void mousePressEvent(QMouseEvent *me);
+
+private:
+    WatchTableModel *m_model;
+};
+
+
+class WatchTableView : public QTableView
+{
+    Q_OBJECT
+public:
+    WatchTableView(WatchTableModel *model, QWidget *parent = 0);
+
+signals:
+    void objectActivated(int objectDebugId);
+
+private slots:
+    void indexActivated(const QModelIndex &index);
+    void watchCreated(QmlDebugWatch *watch);
+
+private:
+    WatchTableModel *m_model;
+};
+
+
+QT_END_NAMESPACE
+
+#endif // WATCHTABLEMODEL_H
diff --git a/tools/qmlviewer/content/Browser.qml b/tools/qmlviewer/content/Browser.qml
new file mode 100644
index 0000000..446045b
--- /dev/null
+++ b/tools/qmlviewer/content/Browser.qml
@@ -0,0 +1,243 @@
+import Qt 4.6
+
+Rectangle {
+    id: root
+    property bool keyPressed: false
+    property var folders: folders1
+    property var view: view1
+    width: 320
+    height: 480
+    color: palette.window
+
+    FolderListModel {
+        id: folders1
+        nameFilters: [ "*.qml" ]
+        folder: qmlViewerFolder
+    }
+    FolderListModel {
+        id: folders2
+        nameFilters: [ "*.qml" ]
+        folder: qmlViewerFolder
+    }
+
+    SystemPalette { id: palette }
+
+    Script {
+        function down(path) {
+            if (folders == folders1) {
+                view = view2
+                folders = folders2;
+                view1.state = "exitLeft";
+            } else {
+                view = view1
+                folders = folders1;
+                view2.state = "exitLeft";
+            }
+            view.x = root.width;
+            view.state = "current";
+            view.focus = true;
+            folders.folder = path;
+        }
+        function up() {
+            var path = folders.parentFolder;
+            if (folders == folders1) {
+                view = view2
+                folders = folders2;
+                view1.state = "exitRight";
+            } else {
+                view = view1
+                folders = folders1;
+                view2.state = "exitRight";
+            }
+            view.x = -root.width;
+            view.state = "current";
+            view.focus = true;
+            folders.folder = path;
+        }
+    }
+
+    Component {
+        id: folderDelegate
+        Rectangle {
+            id: wrapper
+            function launch() {
+                if (folders.isFolder(index)) {
+                    down(filePath);
+                } else {
+                    qmlViewer.launch(filePath);
+                }
+            }
+            width: root.width
+            height: 52
+            color: "transparent"
+            Rectangle {
+                id: highlight; visible: false
+                anchors.fill: parent
+                gradient: Gradient {
+                    GradientStop { id: t1; position: 0.0; color: palette.highlight }
+                    GradientStop { id: t2; position: 1.0; color: Qt.lighter(palette.highlight) }
+                }
+            }
+            Item {
+                width: 48; height: 48
+                Image { source: "images/folder.png"; anchors.centerIn: parent; visible: folders.isFolder(index)}
+            }
+            Text {
+                id: nameText
+                anchors.fill: parent; verticalAlignment: Text.AlignVCenter
+                text: fileName
+                anchors.leftMargin: 54
+                font.pixelSize: 32
+                color: (wrapper.ListView.isCurrentItem && root.keyPressed) ? palette.highlightedText : palette.windowText
+            }
+            MouseRegion {
+                id: mouseRegion
+                anchors.fill: parent
+                onClicked: { launch() }
+            }
+            states: [
+                State {
+                    name: "pressed"
+                    when: mouseRegion.pressed
+                    PropertyChanges { target: highlight; visible: true }
+                    PropertyChanges { target: nameText; color: palette.highlightedText }
+                }
+            ]
+        }
+    }
+
+    ListView {
+        id: view1
+        anchors.top: titleBar.bottom
+        anchors.bottom: parent.bottom
+        x: 0
+        width: parent.width
+        model: folders1
+        delegate: folderDelegate
+        highlight: Rectangle { color: palette.highlight; visible: root.keyPressed && view1.count != 0 }
+        highlightMoveSpeed: 1000
+        pressDelay: 100
+        focus: true
+        state: "current"
+        states: [
+            State {
+                name: "current"
+                PropertyChanges { target: view1; x: 0 }
+            },
+            State {
+                name: "exitLeft"
+                PropertyChanges { target: view1; x: -root.width }
+            },
+            State {
+                name: "exitRight"
+                PropertyChanges { target: view1; x: root.width }
+            }
+        ]
+        transitions: [
+            Transition {
+                to: "current"
+                SequentialAnimation {
+                    NumberAnimation { matchProperties: "x"; duration: 250 }
+                }
+            },
+            Transition {
+                NumberAnimation { matchProperties: "x"; duration: 250 }
+                NumberAnimation { matchProperties: "x"; duration: 250 }
+            }
+        ]
+        Keys.onPressed: { root.keyPressed = true; }
+    }
+
+    ListView {
+        id: view2
+        anchors.top: titleBar.bottom
+        anchors.bottom: parent.bottom
+        x: parent.width
+        width: parent.width
+        model: folders2
+        delegate: folderDelegate
+        highlight: Rectangle { color: palette.highlight; visible: root.keyPressed && view2.count != 0 }
+        highlightMoveSpeed: 1000
+        pressDelay: 100
+        states: [
+            State {
+                name: "current"
+                PropertyChanges { target: view2; x: 0 }
+            },
+            State {
+                name: "exitLeft"
+                PropertyChanges { target: view2; x: -root.width }
+            },
+            State {
+                name: "exitRight"
+                PropertyChanges { target: view2; x: root.width }
+            }
+        ]
+        transitions: [
+            Transition {
+                to: "current"
+                SequentialAnimation {
+                    NumberAnimation { matchProperties: "x"; duration: 250 }
+                }
+            },
+            Transition {
+                NumberAnimation { matchProperties: "x"; duration: 250 }
+            }
+        ]
+        Keys.onPressed: { root.keyPressed = true; }
+    }
+
+    Keys.onPressed: {
+        root.keyPressed = true;
+        if (event.key == Qt.Key_Return || event.key == Qt.Key_Select || event.key == Qt.Key_Right) {
+            view.currentItem.launch();
+            event.accepted = true;
+        } else if (event.key == Qt.Key_Left) {
+            up();
+        }
+    }
+
+    BorderImage {
+        source: "images/titlebar.sci";
+        width: parent.width;
+        height: 52
+        y: -7
+        id: titleBar
+
+        Rectangle {
+            id: upButton
+            width: 48
+            height: titleBar.height - 7
+            color: "transparent"
+
+            Image { anchors.centerIn: parent; source: "images/up.png" }
+            MouseRegion { id: upRegion; anchors.centerIn: parent
+                width: 56
+                height: 56
+                onClicked: if (folders.parentFolder != "") up()
+            }
+            states: [
+                State {
+                    name: "pressed"
+                    when: upRegion.pressed
+                    PropertyChanges { target: upButton; color: palette.highlight }
+                }
+            ]
+        }
+        Rectangle {
+            color: "gray"
+            x: 48
+            width: 1
+            height: 44
+        }
+
+        Text {
+            anchors.left: upButton.right; anchors.right: parent.right; height: parent.height
+            anchors.leftMargin: 4; anchors.rightMargin: 4
+            text: folders.folder
+            color: "white"
+            elide: Text.ElideLeft; horizontalAlignment: Text.AlignRight; verticalAlignment: Text.AlignVCenter
+            font.pixelSize: 32
+        }
+    }
+}
diff --git a/tools/qmlviewer/content/images/folder.png b/tools/qmlviewer/content/images/folder.png
new file mode 100644
index 0000000..e53e2ad
--- /dev/null
+++ b/tools/qmlviewer/content/images/folder.png
diff --git a/tools/qmlviewer/content/images/titlebar.png b/tools/qmlviewer/content/images/titlebar.png
new file mode 100644
index 0000000..51c9008
--- /dev/null
+++ b/tools/qmlviewer/content/images/titlebar.png
diff --git a/tools/qmlviewer/content/images/titlebar.sci b/tools/qmlviewer/content/images/titlebar.sci
new file mode 100644
index 0000000..0418d94
--- /dev/null
+++ b/tools/qmlviewer/content/images/titlebar.sci
@@ -0,0 +1,5 @@
+border.left: 10
+border.top: 12
+border.bottom: 12
+border.right: 10
+source: titlebar.png
diff --git a/tools/qmlviewer/content/images/up.png b/tools/qmlviewer/content/images/up.png
new file mode 100644
index 0000000..b05f802
--- /dev/null
+++ b/tools/qmlviewer/content/images/up.png
diff --git a/tools/qmlviewer/deviceorientation.cpp b/tools/qmlviewer/deviceorientation.cpp
new file mode 100644
index 0000000..c507479
--- /dev/null
+++ b/tools/qmlviewer/deviceorientation.cpp
@@ -0,0 +1,73 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "deviceorientation.h"
+
+class DefaultDeviceOrientation : public DeviceOrientation
+{
+    Q_OBJECT
+public:
+    DefaultDeviceOrientation() : DeviceOrientation(), m_orientation(DeviceOrientation::Portrait) {}
+
+    Orientation orientation() const {
+        return m_orientation;
+    }
+
+    void setOrientation(Orientation o) {
+        if (o != m_orientation) {
+            m_orientation = o;
+            emit orientationChanged();
+        }
+    }
+
+    Orientation m_orientation;
+};
+
+DeviceOrientation* DeviceOrientation::instance()
+{
+    static DefaultDeviceOrientation *o = 0;
+    if (!o)
+        o = new DefaultDeviceOrientation;
+    return o;
+}
+
+#include "deviceorientation.moc"
+
diff --git a/tools/qmlviewer/deviceorientation.h b/tools/qmlviewer/deviceorientation.h
new file mode 100644
index 0000000..fa7758f
--- /dev/null
+++ b/tools/qmlviewer/deviceorientation.h
@@ -0,0 +1,69 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef ORIENTATION_H
+#define ORIENTATION_H
+
+#include <QObject>
+
+class DeviceOrientationPrivate;
+class DeviceOrientation : public QObject
+{
+    Q_OBJECT
+public:
+    enum Orientation { UnknownOrientation, Portrait, Landscape };
+    virtual Orientation orientation() const = 0;
+    virtual void setOrientation(Orientation) = 0;
+
+    static DeviceOrientation *instance();
+
+signals:
+    void orientationChanged();
+
+protected:
+    DeviceOrientation() {}
+
+private:
+    DeviceOrientationPrivate *d_ptr;
+    friend class DeviceOrientationPrivate;
+};
+
+#endif
diff --git a/tools/qmlviewer/deviceorientation_maemo.cpp b/tools/qmlviewer/deviceorientation_maemo.cpp
new file mode 100644
index 0000000..9df9af4
--- /dev/null
+++ b/tools/qmlviewer/deviceorientation_maemo.cpp
@@ -0,0 +1,139 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "deviceorientation.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+class MaemoOrientation : public DeviceOrientation
+{
+    Q_OBJECT
+public:
+    MaemoOrientation()
+        : DeviceOrientation(),m_current(Portrait), m_lastSeen(Portrait), m_lastSeenCount(0)
+    {
+        startTimer(100);
+    }
+
+    Orientation orientation() const {
+        return m_current;
+    }
+
+    void setOrientation(Orientation orient) {
+        //XXX maybe better to just ignore
+        if (orient != m_current) {
+            m_current = orient;
+            emit orientationChanged();
+        }
+    }
+
+
+protected:
+    virtual void timerEvent(QTimerEvent *)
+    {
+        Orientation c = get();
+
+        if (c == m_lastSeen) {
+            m_lastSeenCount++;
+        } else {
+            m_lastSeenCount = 0;
+            m_lastSeen = c;
+        }
+
+        if (m_lastSeen != UnknownOrientation && m_lastSeen != m_current && m_lastSeenCount > 4) {
+            m_current = m_lastSeen;
+            emit orientationChanged();
+            printf("%d\n", m_current);
+        }
+    }
+
+signals:
+    void changed();
+
+private:
+    Orientation m_current;
+    Orientation m_lastSeen;
+    int m_lastSeenCount;
+
+    Orientation get()
+    {
+        Orientation o = UnknownOrientation;
+
+        int ax, ay, az;
+
+        read(&ax, &ay, &az);
+
+        if (abs(az) > 850) {
+            o = UnknownOrientation;
+        } else if (ax < -750) {
+            o = Portrait;
+        } else if (ay < -750) {
+            o = Landscape;
+        }
+
+        return o;
+    }
+
+    int read(int *ax,int *ay,int *az)
+    {
+        static const char *accel_filename = "/sys/class/i2c-adapter/i2c-3/3-001d/coord";
+
+        FILE *fd;
+        int rs;
+        fd = fopen(accel_filename, "r");
+        if(fd==NULL){ printf("liqaccel, cannot open for reading\n"); return -1;}
+        rs=fscanf((FILE*) fd,"%i %i %i",ax,ay,az);
+        fclose(fd);
+        if(rs != 3){ printf("liqaccel, cannot read information\n"); return -2;}
+        return 0;
+    }
+};
+
+
+DeviceOrientation* DeviceOrientation::instance()
+{
+    static MaemoOrientation *o = 0;
+    if (!o)
+        o = new MaemoOrientation;
+    return o;
+}
+
+#include "deviceorientation_maemo.moc"
diff --git a/tools/qmlviewer/main.cpp b/tools/qmlviewer/main.cpp
new file mode 100644
index 0000000..b7a3f1a
--- /dev/null
+++ b/tools/qmlviewer/main.cpp
@@ -0,0 +1,344 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qml.h"
+#include "qmlviewer.h"
+#include <QWidget>
+#include <QDir>
+#include <QApplication>
+#include <QTranslator>
+#include <QDebug>
+
+#if defined (Q_OS_SYMBIAN)
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+void myMessageOutput(QtMsgType type, const char *msg)
+{
+    static int fd = -1;
+    if (fd == -1)
+        fd = ::open("E:\\qmlviewer.log", O_WRONLY | O_CREAT);
+
+    ::write(fd, msg, strlen(msg));
+    ::write(fd, "\n", 1);
+    ::fsync(fd);
+
+    switch (type) {
+    case QtFatalMsg:
+        abort();
+    }
+}
+#endif
+
+void usage()
+{
+    qWarning("Usage: qmlviewer [options] <filename>");
+    qWarning(" ");
+    qWarning(" options:");
+    qWarning("  -v, -version ............................. display version");
+    qWarning("  -frameless ............................... run with no window frame");
+    qWarning("  -maximized................................ run maximized");
+    qWarning("  -fullscreen............................... run fullscreen");
+    qWarning("  -stayontop................................ keep viewer window on top");
+    qWarning("  -skin <qvfbskindir> ...................... run with a skin window frame");
+    qWarning("                                             \"list\" for a list of built-ins");
+    qWarning("  -resizeview .............................. resize the view, not the skin");
+    qWarning("  -qmlbrowser .............................. use a QML-based file browser");
+    qWarning("  -recordfile <output> ..................... set video recording file");
+    qWarning("                                              - ImageMagick 'convert' for GIF)");
+    qWarning("                                              - png file for raw frames");
+    qWarning("                                              - 'ffmpeg' for other formats");
+    qWarning("  -recorddither ordered|threshold|floyd .... set GIF dither recording mode");
+    qWarning("  -recordrate <fps> ........................ set recording frame rate");
+    qWarning("  -record arg .............................. add a recording process argument");
+    qWarning("  -autorecord [from-]<tomilliseconds> ...... set recording to start and stop");
+    qWarning("  -devicekeys .............................. use numeric keys (see F1)");
+    qWarning("  -netcache <size> ......................... set disk cache to size bytes");
+    qWarning("  -translation <translationfile> ........... set the language to run in");
+    qWarning("  -L <directory> ........................... prepend to the library search path");
+    qWarning("  -opengl .................................. use a QGLWidget for the viewport");
+    qWarning("  -script <path> ........................... set the script to use");
+    qWarning("  -scriptopts <options>|help ............... set the script options to use");
+
+    qWarning(" ");
+    qWarning(" Press F1 for interactive help");
+    exit(1);
+}
+
+void scriptOptsUsage()
+{
+    qWarning("Usage: qmlviewer -scriptopts <option>[,<option>...] ...");
+    qWarning(" options:");
+    qWarning("  record ................................... record a new script");
+    qWarning("  play ..................................... playback an existing script");
+    qWarning("  testimages ............................... record images or compare images on playback");
+    qWarning("  testerror ................................ test 'error' property of root item on playback");
+    qWarning("  exitoncomplete ........................... cleanly exit the viewer on script completion");
+    qWarning("  exitonfailure ............................ immediately exit the viewer on script failure");
+    qWarning("  saveonexit ............................... save recording on viewer exit");
+    qWarning(" ");
+    qWarning(" One of record, play or both must be specified.");
+    exit(1);
+}
+
+int main(int argc, char ** argv)
+{
+#if defined (Q_OS_SYMBIAN)
+    qInstallMsgHandler(myMessageOutput);
+#endif
+
+#if defined (Q_WS_X11)
+    //### default to using raster graphics backend for now
+    bool gsSpecified = false;
+    for (int i = 0; i < argc; ++i) {
+        QString arg = argv[i];
+        if (arg == "-graphicssystem") {
+            gsSpecified = true;
+            break;
+        }
+    }
+
+    if (!gsSpecified)
+        QApplication::setGraphicsSystem("raster");
+#endif
+
+    QApplication app(argc, argv);
+    app.setApplicationName("viewer");
+    app.setOrganizationName("Nokia");
+    app.setOrganizationDomain("nokia.com");
+
+    bool frameless = false;
+    bool resizeview = false;
+    QString fileName;
+    double fps = 0;
+    int autorecord_from = 0;
+    int autorecord_to = 0;
+    QString dither = "none";
+    QString recordfile;
+    QStringList recordargs;
+    QStringList libraries;
+    QString skin;
+    QString script;
+    QString scriptopts;
+    bool runScript = false;
+    bool devkeys = false;
+    int cache = 0;
+    QString translationFile;
+    bool useGL = false;
+    bool fullScreen = false;
+    bool stayOnTop = false;
+    bool maximized = false;
+    bool useNativeFileBrowser = true;
+
+#if defined(Q_OS_SYMBIAN)
+    maximized = true;
+    useNativeFileBrowser = false;
+#endif
+
+    for (int i = 1; i < argc; ++i) {
+        bool lastArg = (i == argc - 1);
+        QString arg = argv[i];
+        if (arg == "-frameless") {
+            frameless = true;
+        } else if (arg == "-maximized") {
+            maximized = true;
+        } else if (arg == "-fullscreen") {
+            fullScreen = true;
+        } else if (arg == "-stayontop") {
+            stayOnTop = true;
+        } else if (arg == "-skin") {
+            if (lastArg) usage();
+            skin = QString(argv[++i]);
+        } else if (arg == "-resizeview") {
+            resizeview = true;
+        } else if (arg == "-netcache") {
+            if (lastArg) usage();
+            cache = QString(argv[++i]).toInt();
+        } else if (arg == "-recordrate") {
+            if (lastArg) usage();
+            fps = QString(argv[++i]).toDouble();
+        } else if (arg == "-recordfile") {
+            if (lastArg) usage();
+            recordfile = QString(argv[++i]);
+        } else if (arg == "-record") {
+            if (lastArg) usage();
+            recordargs << QString(argv[++i]);
+        } else if (arg == "-recorddither") {
+            if (lastArg) usage();
+            dither = QString(argv[++i]);
+        } else if (arg == "-autorecord") {
+            if (lastArg) usage();
+            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 == QLatin1String("-v") || arg == QLatin1String("-version")) {
+            fprintf(stderr, "Qt Declarative UI Viewer version %s\n", QT_VERSION_STR);
+            return 0;
+        } else if (arg == "-translation") {
+            if (lastArg) usage();
+            translationFile = argv[++i];
+        } else if (arg == "-opengl") {
+            useGL = true;
+        } else if (arg == "-qmlbrowser") {
+            useNativeFileBrowser = false;
+        } else if (arg == "-L") {
+            if (lastArg) usage();
+            libraries << QString(argv[++i]);
+        } else if (arg == "-script") {
+            if (lastArg) usage();
+            script = QString(argv[++i]);
+        } else if (arg == "-scriptopts") {
+            if (lastArg) usage();
+            scriptopts = QString(argv[++i]);
+        } else if (arg == "-savescript") {
+            if (lastArg) usage();
+            script = QString(argv[++i]);
+            runScript = false;
+        } else if (arg == "-playscript") {
+            if (lastArg) usage();
+            script = QString(argv[++i]);
+            runScript = true;
+        } else if (arg[0] != '-') {
+            fileName = arg;
+        } else if (1 || arg == "-help") {
+            usage();
+        }
+    }
+
+    QTranslator qmlTranslator;
+    if (!translationFile.isEmpty()) {
+        qmlTranslator.load(translationFile);
+        app.installTranslator(&qmlTranslator);
+    }
+
+    Qt::WFlags wflags = (frameless ? Qt::FramelessWindowHint : Qt::Widget);
+    if (stayOnTop)
+        wflags |= Qt::WindowStaysOnTopHint;
+
+    QmlViewer viewer(0, wflags);
+    if (!scriptopts.isEmpty()) {
+        QStringList options = 
+            scriptopts.split(QLatin1Char(','), QString::SkipEmptyParts);
+
+        QmlViewer::ScriptOptions scriptOptions = 0;
+        for (int i = 0; i < options.count(); ++i) {
+            const QString &option = options.at(i);
+            if (option == QLatin1String("help")) {
+                scriptOptsUsage();
+            } else if (option == QLatin1String("play")) {
+                scriptOptions |= QmlViewer::Play;
+            } else if (option == QLatin1String("record")) {
+                scriptOptions |= QmlViewer::Record;
+            } else if (option == QLatin1String("testimages")) {
+                scriptOptions |= QmlViewer::TestImages;
+            } else if (option == QLatin1String("testerror")) {
+                scriptOptions |= QmlViewer::TestErrorProperty;
+            } else if (option == QLatin1String("exitoncomplete")) {
+                scriptOptions |= QmlViewer::ExitOnComplete;
+            } else if (option == QLatin1String("exitonfailure")) {
+                scriptOptions |= QmlViewer::ExitOnFailure;
+            } else if (option == QLatin1String("saveonexit")) {
+                scriptOptions |= QmlViewer::SaveOnExit;
+            } else {
+                scriptOptsUsage();
+            }
+        }
+
+        if (script.isEmpty())
+            usage();
+
+        if (!(scriptOptions & QmlViewer::Record) && !(scriptOptions & QmlViewer::Play))
+            scriptOptsUsage();
+        viewer.setScriptOptions(scriptOptions);
+        viewer.setScript(script);
+    }  else if (!script.isEmpty()) {
+        usage();
+    }
+
+    foreach (QString lib, libraries)
+        viewer.addLibraryPath(lib);
+    viewer.setNetworkCacheSize(cache);
+    viewer.setRecordFile(recordfile);
+    if (resizeview)
+        viewer.setScaleView();
+    if (fps>0)
+        viewer.setRecordRate(fps);
+    if (autorecord_to)
+        viewer.setAutoRecord(autorecord_from,autorecord_to);
+    if (!skin.isEmpty()) {
+        if (skin == "list") {
+            foreach (QString s, viewer.builtinSkins())
+                qWarning(s.toUtf8());
+            exit(0);
+        } else {
+            viewer.setSkin(skin);
+        }
+    }
+    if (devkeys)
+        viewer.setDeviceKeys(true);
+    viewer.setRecordDither(dither);
+    if (recordargs.count())
+        viewer.setRecordArgs(recordargs);
+
+    viewer.setUseNativeFileBrowser(useNativeFileBrowser);
+    if (fullScreen && maximized)
+        qWarning() << "Both -fullscreen and -maximized specified. Using -fullscreen.";
+    if (!fileName.isEmpty()) {
+        viewer.open(fileName);
+        fullScreen ? viewer.showFullScreen() : maximized ? viewer.showMaximized() : viewer.show();
+    } else {
+        if (!useNativeFileBrowser)
+            viewer.openFile();
+        fullScreen ? viewer.showFullScreen() : maximized ? viewer.showMaximized() : viewer.show();
+        if (useNativeFileBrowser)
+            viewer.openFile();
+    }
+    viewer.setUseGL(useGL);
+    viewer.raise();
+
+    return app.exec();
+}
diff --git a/tools/qmlviewer/proxysettings.cpp b/tools/qmlviewer/proxysettings.cpp
new file mode 100644
index 0000000..52fa74f
--- /dev/null
+++ b/tools/qmlviewer/proxysettings.cpp
@@ -0,0 +1,106 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QIntValidator>
+#include <QSettings>
+
+#include "proxysettings.h"
+
+ProxySettings::ProxySettings (QWidget * parent)
+        : QDialog (parent), Ui::ProxySettings()
+{
+    setupUi (this);
+
+    proxyServerEdit->setInputMask ("000.000.000.000;_");
+    QIntValidator *validator = new QIntValidator (0, 9999, this);
+    proxyPortEdit->setValidator (validator);
+
+    QSettings settings;
+    proxyCheckBox->setChecked (settings.value ("http_proxy/use", 0).toBool ());
+    proxyServerEdit->insert (settings.value ("http_proxy/hostname", "").toString ());
+    proxyPortEdit->insert (settings.value ("http_proxy/port", "80").toString ());
+    usernameEdit->insert (settings.value ("http_proxy/username", "").toString ());
+    passwordEdit->insert (settings.value ("http_proxy/password", "").toString ());
+}
+
+ProxySettings::~ProxySettings()
+{
+}
+
+void ProxySettings::accept ()
+{
+    QSettings settings;
+
+    settings.setValue ("http_proxy/use", proxyCheckBox->isChecked ());
+    settings.setValue ("http_proxy/hostname", proxyServerEdit->text ());
+    settings.setValue ("http_proxy/port", proxyPortEdit->text ());
+    settings.setValue ("http_proxy/username", usernameEdit->text ());
+    settings.setValue ("http_proxy/password", passwordEdit->text ());
+
+    QDialog::accept ();
+}
+
+QNetworkProxy ProxySettings::httpProxy ()
+{
+    QSettings settings;
+    QNetworkProxy proxy;
+
+    bool proxyInUse = settings.value ("http_proxy/use", 0).toBool ();
+    if (proxyInUse) {
+        proxy.setType (QNetworkProxy::HttpProxy);
+        proxy.setHostName (settings.value ("http_proxy/hostname", "").toString ());// "192.168.220.5"
+        proxy.setPort (settings.value ("http_proxy/port", 80).toInt ());  // 8080
+        proxy.setUser (settings.value ("http_proxy/username", "").toString ());
+        proxy.setPassword (settings.value ("http_proxy/password", "").toString ());
+        //QNetworkProxy::setApplicationProxy (proxy);
+    }
+    else {
+        proxy.setType (QNetworkProxy::NoProxy);
+    }
+    return proxy;
+}
+
+bool ProxySettings::httpProxyInUse()
+{
+    QSettings settings;
+    return settings.value ("http_proxy/use", 0).toBool ();
+}
diff --git a/tools/qmlviewer/proxysettings.h b/tools/qmlviewer/proxysettings.h
new file mode 100644
index 0000000..b2f3e25
--- /dev/null
+++ b/tools/qmlviewer/proxysettings.h
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef PROXYSETTINGS_H
+#define PROXYSETTINGS_H
+
+#include <QDialog>
+#include <QNetworkProxy>
+#include "ui_proxysettings.h"
+
+/**
+*/
+class ProxySettings : public QDialog, public Ui::ProxySettings
+{
+
+Q_OBJECT
+
+public:
+    ProxySettings(QWidget * parent = 0);
+
+    ~ProxySettings();
+
+    static QNetworkProxy httpProxy ();
+    static bool httpProxyInUse ();
+
+public slots:
+    virtual void accept ();
+};
+
+#endif // PROXYSETTINGS_H
diff --git a/tools/qmlviewer/proxysettings.ui b/tools/qmlviewer/proxysettings.ui
new file mode 100644
index 0000000..84e39fe
--- /dev/null
+++ b/tools/qmlviewer/proxysettings.ui
@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ProxySettings</class>
+ <widget class="QDialog" name="ProxySettings">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>318</width>
+    <height>199</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dialog</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="0" colspan="2">
+    <widget class="QCheckBox" name="proxyCheckBox">
+     <property name="text">
+      <string>Use http proxy</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0">
+    <widget class="QLabel" name="serverAddressLabel">
+     <property name="text">
+      <string>Server Address:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="1">
+    <widget class="QLineEdit" name="proxyServerEdit"/>
+   </item>
+   <item row="2" column="0">
+    <widget class="QLabel" name="label">
+     <property name="text">
+      <string>Port:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="1">
+    <widget class="QLineEdit" name="proxyPortEdit"/>
+   </item>
+   <item row="3" column="0">
+    <widget class="QLabel" name="usernameLabel">
+     <property name="text">
+      <string>Username:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="1">
+    <widget class="QLineEdit" name="usernameEdit"/>
+   </item>
+   <item row="4" column="0">
+    <widget class="QLabel" name="passwordLabel">
+     <property name="text">
+      <string>Password:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="4" column="1">
+    <widget class="QLineEdit" name="passwordEdit">
+     <property name="echoMode">
+      <enum>QLineEdit::Password</enum>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="0" colspan="2">
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>ProxySettings</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>ProxySettings</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/tools/qmlviewer/qfxtester.cpp b/tools/qmlviewer/qfxtester.cpp
new file mode 100644
index 0000000..bd96545
--- /dev/null
+++ b/tools/qmlviewer/qfxtester.cpp
@@ -0,0 +1,378 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qfxtester.h>
+#include <QDebug>
+#include <QApplication>
+#include <qmlview.h>
+#include <QFile>
+#include <QmlComponent>
+#include <QDir>
+#include <QCryptographicHash>
+#include <private/qabstractanimation_p.h>
+#include <private/qmlgraphicsitem_p.h>
+
+QT_BEGIN_NAMESPACE
+
+QML_DEFINE_TYPE(Qt.VisualTest, 4,6, VisualTest, QmlGraphicsVisualTest);
+QML_DEFINE_TYPE(Qt.VisualTest, 4,6, Frame, QmlGraphicsVisualTestFrame);
+QML_DEFINE_TYPE(Qt.VisualTest, 4,6, Mouse, QmlGraphicsVisualTestMouse);
+QML_DEFINE_TYPE(Qt.VisualTest, 4,6, Key, QmlGraphicsVisualTestKey);
+
+QmlGraphicsTester::QmlGraphicsTester(const QString &script, QmlViewer::ScriptOptions opts, 
+                     QmlView *parent)
+: QAbstractAnimation(parent), m_script(script), m_view(parent), filterEvents(true), options(opts), 
+  testscript(0), hasCompleted(false), hasFailed(false)
+{
+    parent->viewport()->installEventFilter(this);
+    parent->installEventFilter(this);
+    QUnifiedTimer::instance()->setConsistentTiming(true);
+    if (options & QmlViewer::Play)
+        this->run();
+    start();
+}
+
+QmlGraphicsTester::~QmlGraphicsTester()
+{
+    if (!hasFailed && 
+        options & QmlViewer::Record && 
+        options & QmlViewer::SaveOnExit)
+        save();
+}
+
+int QmlGraphicsTester::duration() const
+{
+    return -1;
+}
+
+void QmlGraphicsTester::addMouseEvent(Destination dest, QMouseEvent *me)
+{
+    MouseEvent e(me);
+    e.destination = dest;
+    m_mouseEvents << e;
+}
+
+void QmlGraphicsTester::addKeyEvent(Destination dest, QKeyEvent *ke)
+{
+    KeyEvent e(ke);
+    e.destination = dest;
+    m_keyEvents << e;
+}
+
+bool QmlGraphicsTester::eventFilter(QObject *o, QEvent *e)
+{
+    if (!filterEvents)
+        return false;
+
+    Destination destination;
+    if (o == m_view) {
+        destination = View;
+    } else if (o == m_view->viewport()) {
+        destination = ViewPort;
+    } else {
+        return false;
+    }
+
+    switch (e->type()) {
+        case QEvent::KeyPress:
+        case QEvent::KeyRelease:
+            addKeyEvent(destination, (QKeyEvent *)e);
+            return true;
+        case QEvent::MouseButtonPress:
+        case QEvent::MouseButtonRelease:
+        case QEvent::MouseMove:
+        case QEvent::MouseButtonDblClick:
+            addMouseEvent(destination, (QMouseEvent *)e);
+            return true;
+        default:
+            break;
+    }
+    return false;
+}
+
+void QmlGraphicsTester::executefailure()
+{
+    hasFailed = true;
+
+    if (options & QmlViewer::ExitOnFailure)
+        exit(-1);
+}
+
+void QmlGraphicsTester::imagefailure()
+{
+    hasFailed = true;
+
+    if (options & QmlViewer::ExitOnFailure)
+        exit(-1);
+}
+
+void QmlGraphicsTester::complete()
+{
+    if ((options & QmlViewer::TestErrorProperty) && !hasFailed) {
+        QString e = m_view->root()->property("error").toString();
+        if (!e.isEmpty()) {
+            qWarning() << "Test failed:" << e;
+            hasFailed = true;
+        }
+    }
+    if (options & QmlViewer::ExitOnComplete) 
+        QApplication::exit(hasFailed?-1:0);
+
+    if (hasCompleted)
+        return;
+    hasCompleted = true;
+
+    if (options & QmlViewer::Play)
+        qWarning("Script playback complete");
+}
+
+void QmlGraphicsTester::run()
+{
+    QmlComponent c(m_view->engine(), m_script + QLatin1String(".qml"));
+
+    testscript = qobject_cast<QmlGraphicsVisualTest *>(c.create());
+    if (testscript) testscript->setParent(this);
+    else { executefailure(); exit(-1); }
+    testscriptidx = 0;
+}
+
+void QmlGraphicsTester::save()
+{
+    QString filename = m_script + QLatin1String(".qml");
+    QFileInfo filenameInfo(filename);
+    QDir saveDir = filenameInfo.absoluteDir();
+    saveDir.mkpath(".");
+
+    QFile file(filename);
+    file.open(QIODevice::WriteOnly);
+    QTextStream ts(&file);
+
+    ts << "import Qt.VisualTest 4.6\n\n";
+    ts << "VisualTest {\n";
+
+    int imgCount = 0;
+    QList<KeyEvent> keyevents = m_savedKeyEvents;
+    QList<MouseEvent> mouseevents = m_savedMouseEvents;
+    for (int ii = 0; ii < m_savedFrameEvents.count(); ++ii) {
+        const FrameEvent &fe = m_savedFrameEvents.at(ii);
+        ts << "    Frame {\n";
+        ts << "        msec: " << fe.msec << "\n";
+        if (!fe.hash.isEmpty()) {
+            ts << "        hash: \"" << fe.hash.toHex() << "\"\n";
+        } else if (!fe.image.isNull()) {
+            QString filename = filenameInfo.baseName() + "." + QString::number(imgCount) + ".png";
+            fe.image.save(m_script + "." + QString::number(imgCount) + ".png");
+            imgCount++;
+            ts << "        image: \"" << filename << "\"\n";
+        }
+        ts << "    }\n";
+
+        while (!mouseevents.isEmpty() && 
+               mouseevents.first().msec == fe.msec) {
+            MouseEvent me = mouseevents.takeFirst();
+
+            ts << "    Mouse {\n";
+            ts << "        type: " << me.type << "\n";
+            ts << "        button: " << me.button << "\n";
+            ts << "        buttons: " << me.buttons << "\n";
+            ts << "        x: " << me.pos.x() << "; y: " << me.pos.y() << "\n";
+            ts << "        modifiers: " << me.modifiers << "\n";
+            if (me.destination == ViewPort)
+                ts << "        sendToViewport: true\n";
+            ts << "    }\n";
+        }
+
+        while (!keyevents.isEmpty() &&
+               keyevents.first().msec == fe.msec) {
+            KeyEvent ke = keyevents.takeFirst();
+
+            ts << "    Key {\n";
+            ts << "        type: " << ke.type << "\n";
+            ts << "        key: " << ke.key << "\n";
+            ts << "        modifiers: " << ke.modifiers << "\n";
+            ts << "        text: \"" << ke.text.toUtf8().toHex() << "\"\n";
+            ts << "        autorep: " << (ke.autorep?"true":"false") << "\n";
+            ts << "        count: " << ke.count << "\n";
+            if (ke.destination == ViewPort)
+                ts << "        sendToViewport: true\n";
+            ts << "    }\n";
+        }
+    }
+
+    ts << "}\n";
+    file.close();
+}
+
+void QmlGraphicsTester::updateCurrentTime(int msec)
+{
+    QmlGraphicsItemPrivate::setConsistentTime(msec);
+
+    QImage img(m_view->width(), m_view->height(), QImage::Format_RGB32);
+
+    if (options & QmlViewer::TestImages) {
+        img.fill(qRgb(255,255,255));
+        QPainter p(&img);
+        m_view->render(&p);
+    }
+
+    FrameEvent fe;
+    fe.msec = msec;
+    if (msec == 0 || !(options & QmlViewer::TestImages)) {
+        // Skip first frame, skip if not doing images
+    } else if (0 == (m_savedFrameEvents.count() % 60)) {
+        fe.image = img;
+    } else {
+        QCryptographicHash hash(QCryptographicHash::Md5);
+        hash.addData((const char *)img.bits(), img.bytesPerLine() * img.height());
+        fe.hash = hash.result();
+    }
+    m_savedFrameEvents.append(fe);
+
+    // Deliver mouse events
+    filterEvents = false;
+
+    if (!testscript) {
+        for (int ii = 0; ii < m_mouseEvents.count(); ++ii) {
+            MouseEvent &me = m_mouseEvents[ii];
+            me.msec = msec;
+            QMouseEvent event(me.type, me.pos, me.button, me.buttons, me.modifiers);
+
+            if (me.destination == View) {
+                QCoreApplication::sendEvent(m_view, &event);
+            } else {
+                QCoreApplication::sendEvent(m_view->viewport(), &event);
+            }
+        }
+
+        for (int ii = 0; ii < m_keyEvents.count(); ++ii) {
+            KeyEvent &ke = m_keyEvents[ii];
+            ke.msec = msec;
+            QKeyEvent event(ke.type, ke.key, ke.modifiers, ke.text, ke.autorep, ke.count);
+
+            if (ke.destination == View) {
+                QCoreApplication::sendEvent(m_view, &event);
+            } else {
+                QCoreApplication::sendEvent(m_view->viewport(), &event);
+            }
+        }
+        m_savedMouseEvents.append(m_mouseEvents);
+        m_savedKeyEvents.append(m_keyEvents);
+    }
+
+    m_mouseEvents.clear();
+    m_keyEvents.clear();
+
+    // Advance test script
+    static int imgCount = 0;
+    while (testscript && testscript->count() > testscriptidx) {
+
+        QObject *event = testscript->event(testscriptidx);
+
+        if (QmlGraphicsVisualTestFrame *frame = qobject_cast<QmlGraphicsVisualTestFrame *>(event)) {
+            if (frame->msec() < msec) {
+                if (options & QmlViewer::TestImages && !(options & QmlViewer::Record)) {
+                    qWarning() << "QmlGraphicsTester: Extra frame.  Seen:" 
+                               << msec << "Expected:" << frame->msec();
+                    imagefailure();
+                }
+            } else if (frame->msec() == msec) {
+                if (!frame->hash().isEmpty() && frame->hash().toUtf8() != fe.hash.toHex()) {
+                    if (options & QmlViewer::TestImages && !(options & QmlViewer::Record)) {
+                        qWarning() << "QmlGraphicsTester: Mismatched frame hash.  Seen:" 
+                                   << fe.hash.toHex() << "Expected:" 
+                                   << frame->hash().toUtf8();
+                        imagefailure();
+                    }
+                }
+            } else if (frame->msec() > msec) {
+                break;
+            }
+
+            if (options & QmlViewer::TestImages && !(options & QmlViewer::Record) && !frame->image().isEmpty()) {
+                QImage goodImage(frame->image().toLocalFile());
+                if (goodImage != img) {
+                    QString reject(frame->image().toLocalFile() + ".reject.png");
+                    qWarning() << "QmlGraphicsTester: Image mismatch.  Reject saved to:" 
+                               << reject;
+                    img.save(reject);
+                    imagefailure();
+                }
+            }
+        } else if (QmlGraphicsVisualTestMouse *mouse = qobject_cast<QmlGraphicsVisualTestMouse *>(event)) {
+            QPoint pos(mouse->x(), mouse->y());
+            QPoint globalPos = m_view->mapToGlobal(QPoint(0, 0)) + pos;
+            QMouseEvent event((QEvent::Type)mouse->type(), pos, globalPos, (Qt::MouseButton)mouse->button(), (Qt::MouseButtons)mouse->buttons(), (Qt::KeyboardModifiers)mouse->modifiers());
+
+            MouseEvent me(&event);
+            me.msec = msec;
+            if (!mouse->sendToViewport()) {
+                QCoreApplication::sendEvent(m_view, &event);
+                me.destination = View;
+            } else {
+                QCoreApplication::sendEvent(m_view->viewport(), &event);
+                me.destination = ViewPort;
+            }
+            m_savedMouseEvents.append(me);
+        } else if (QmlGraphicsVisualTestKey *key = qobject_cast<QmlGraphicsVisualTestKey *>(event)) {
+
+            QKeyEvent event((QEvent::Type)key->type(), key->key(), (Qt::KeyboardModifiers)key->modifiers(), QString::fromUtf8(QByteArray::fromHex(key->text().toUtf8())), key->autorep(), key->count());
+
+            KeyEvent ke(&event);
+            ke.msec = msec;
+            if (!key->sendToViewport()) {
+                QCoreApplication::sendEvent(m_view, &event);
+                ke.destination = View;
+            } else {
+                QCoreApplication::sendEvent(m_view->viewport(), &event);
+                ke.destination = ViewPort;
+            }
+            m_savedKeyEvents.append(ke);
+        } 
+        testscriptidx++;
+    }
+
+    filterEvents = true;
+
+    if (testscript && testscript->count() <= testscriptidx)
+        complete();
+}
+
+QT_END_NAMESPACE
diff --git a/tools/qmlviewer/qfxtester.h b/tools/qmlviewer/qfxtester.h
new file mode 100644
index 0000000..303ac3a
--- /dev/null
+++ b/tools/qmlviewer/qfxtester.h
@@ -0,0 +1,262 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QFXTESTER_H
+#define QFXTESTER_H
+
+#include <QEvent>
+#include <QMouseEvent>
+#include <QKeyEvent>
+#include <qmlviewer.h>
+
+QT_BEGIN_NAMESPACE
+
+class QmlGraphicsVisualTest : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QList<QObject *>* events READ events CONSTANT)
+    Q_CLASSINFO("DefaultProperty", "events")
+public:
+    QmlGraphicsVisualTest() {}
+
+    QList<QObject *> *events() { return &m_events; }
+
+    int count() const { return m_events.count(); }
+    QObject *event(int idx) { return m_events.at(idx); }
+
+private:
+    QList<QObject *> m_events;
+};
+QML_DECLARE_TYPE(QmlGraphicsVisualTest)
+
+class QmlGraphicsVisualTestFrame : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int msec READ msec WRITE setMsec)
+    Q_PROPERTY(QString hash READ hash WRITE setHash)
+    Q_PROPERTY(QUrl image READ image WRITE setImage)
+public:
+    QmlGraphicsVisualTestFrame() : m_msec(-1) {}
+
+    int msec() const { return m_msec; }
+    void setMsec(int m) { m_msec = m; }
+
+    QString hash() const { return m_hash; }
+    void setHash(const QString &hash) { m_hash = hash; }
+
+    QUrl image() const { return m_image; }
+    void setImage(const QUrl &image) { m_image = image; }
+
+private:
+    int m_msec;
+    QString m_hash;
+    QUrl m_image;
+};
+QML_DECLARE_TYPE(QmlGraphicsVisualTestFrame)
+
+class QmlGraphicsVisualTestMouse : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int type READ type WRITE setType)
+    Q_PROPERTY(int button READ button WRITE setButton)
+    Q_PROPERTY(int buttons READ buttons WRITE setButtons)
+    Q_PROPERTY(int x READ x WRITE setX)
+    Q_PROPERTY(int y READ y WRITE setY)
+    Q_PROPERTY(int modifiers READ modifiers WRITE setModifiers)
+    Q_PROPERTY(bool sendToViewport READ sendToViewport WRITE setSendToViewport)
+public:
+    QmlGraphicsVisualTestMouse() : m_type(0), m_button(0), m_buttons(0), m_x(0), m_y(0), m_modifiers(0), m_viewport(false) {}
+
+    int type() const { return m_type; }
+    void setType(int t) { m_type = t; }
+    
+    int button() const { return m_button; }
+    void setButton(int b) { m_button = b; }
+
+    int buttons() const { return m_buttons; }
+    void setButtons(int b) { m_buttons = b; }
+
+    int x() const { return m_x; }
+    void setX(int x) { m_x = x; }
+
+    int y() const { return m_y; }
+    void setY(int y) { m_y = y; }
+
+    int modifiers() const { return m_modifiers; }
+    void setModifiers(int modifiers) { m_modifiers = modifiers; }
+
+    bool sendToViewport() const { return m_viewport; }
+    void setSendToViewport(bool v) { m_viewport = v; }
+private:
+    int m_type;
+    int m_button;
+    int m_buttons;
+    int m_x;
+    int m_y;
+    int m_modifiers;
+    bool m_viewport;
+};
+QML_DECLARE_TYPE(QmlGraphicsVisualTestMouse)
+
+class QmlGraphicsVisualTestKey : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(int type READ type WRITE setType)
+    Q_PROPERTY(int key READ key WRITE setKey)
+    Q_PROPERTY(int modifiers READ modifiers WRITE setModifiers)
+    Q_PROPERTY(QString text READ text WRITE setText)
+    Q_PROPERTY(bool autorep READ autorep WRITE setAutorep)
+    Q_PROPERTY(int count READ count WRITE setCount)
+    Q_PROPERTY(bool sendToViewport READ sendToViewport WRITE setSendToViewport)
+public:
+    QmlGraphicsVisualTestKey() : m_type(0), m_key(0), m_modifiers(0), m_autorep(false), m_count(0), m_viewport(false) {}
+
+    int type() const { return m_type; }
+    void setType(int t) { m_type = t; }
+
+    int key() const { return m_key; }
+    void setKey(int k) { m_key = k; }
+
+    int modifiers() const { return m_modifiers; }
+    void setModifiers(int m) { m_modifiers = m; }
+
+    QString text() const { return m_text; }
+    void setText(const QString &t) { m_text = t; }
+
+    bool autorep() const { return m_autorep; }
+    void setAutorep(bool a) { m_autorep = a; }
+
+    int count() const { return m_count; }
+    void setCount(int c) { m_count = c; }
+
+    bool sendToViewport() const { return m_viewport; }
+    void setSendToViewport(bool v) { m_viewport = v; }
+private:
+    int m_type;
+    int m_key;
+    int m_modifiers;
+    QString m_text;
+    bool m_autorep;
+    int m_count;
+    bool m_viewport;
+};
+QML_DECLARE_TYPE(QmlGraphicsVisualTestKey)
+
+class QmlGraphicsTester : public QAbstractAnimation
+{
+public:
+    QmlGraphicsTester(const QString &script, QmlViewer::ScriptOptions options, QmlView *parent);
+    ~QmlGraphicsTester();
+
+    virtual int duration() const;
+
+    void run();
+    void save();
+
+    void executefailure();
+protected:
+    virtual void updateCurrentTime(int msecs);
+    virtual bool eventFilter(QObject *, QEvent *);
+
+private:
+    QString m_script;
+
+    void imagefailure();
+    void complete();
+
+    enum Destination { View, ViewPort };
+    void addKeyEvent(Destination, QKeyEvent *);
+    void addMouseEvent(Destination, QMouseEvent *);
+    QmlView *m_view;
+
+    struct MouseEvent {
+        MouseEvent(QMouseEvent *e)
+            : type(e->type()), button(e->button()), buttons(e->buttons()), 
+              pos(e->pos()), modifiers(e->modifiers()), destination(View) {}
+
+        QEvent::Type type;
+        Qt::MouseButton button;
+        Qt::MouseButtons buttons;
+        QPoint pos;
+        Qt::KeyboardModifiers modifiers;
+        Destination destination;
+
+        int msec;
+    };
+    struct KeyEvent {
+        KeyEvent(QKeyEvent *e)
+            : type(e->type()), key(e->key()), modifiers(e->modifiers()), text(e->text()),
+              autorep(e->isAutoRepeat()), count(e->count()), destination(View) {}
+        QEvent::Type type;
+        int key;
+        Qt::KeyboardModifiers modifiers;
+        QString text;
+        bool autorep;
+        ushort count;
+        Destination destination;
+
+        int msec;
+    };
+    struct FrameEvent {
+        QImage image;
+        QByteArray hash;
+        int msec;
+    };
+    QList<MouseEvent> m_mouseEvents;
+    QList<KeyEvent> m_keyEvents;
+
+    QList<MouseEvent> m_savedMouseEvents;
+    QList<KeyEvent> m_savedKeyEvents;
+    QList<FrameEvent> m_savedFrameEvents;
+    bool filterEvents;
+
+    QmlViewer::ScriptOptions options;
+    int testscriptidx;
+    QmlGraphicsVisualTest *testscript;
+
+    bool hasCompleted;
+    bool hasFailed;
+};
+
+
+QT_END_NAMESPACE
+
+#endif // QFXTESTER_H
diff --git a/tools/qmlviewer/qmlfolderlistmodel.cpp b/tools/qmlviewer/qmlfolderlistmodel.cpp
new file mode 100644
index 0000000..35c672d
--- /dev/null
+++ b/tools/qmlviewer/qmlfolderlistmodel.cpp
@@ -0,0 +1,416 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qmlfolderlistmodel.h"
+#include <QDirModel>
+#include <QDebug>
+#include <qmlcontext.h>
+
+class QmlFolderListModelPrivate
+{
+public:
+    QmlFolderListModelPrivate()
+        : sortField(QmlFolderListModel::Name), sortReversed(false), count(0) {
+        nameFilters << QLatin1String("*");
+    }
+
+    void updateSorting() {
+        QDir::SortFlags flags = 0;
+        switch(sortField) {
+        case QmlFolderListModel::Unsorted:
+            flags |= QDir::Unsorted;
+            break;
+        case QmlFolderListModel::Name:
+            flags |= QDir::Name;
+            break;
+        case QmlFolderListModel::Time:
+            flags |= QDir::Time;
+            break;
+        case QmlFolderListModel::Size:
+            flags |= QDir::Size;
+            break;
+        case QmlFolderListModel::Type:
+            flags |= QDir::Type;
+            break;
+        }
+
+        if (sortReversed)
+            flags |= QDir::Reversed;
+
+        model.setSorting(flags);
+    }
+
+    QDirModel model;
+    QUrl folder;
+    QStringList nameFilters;
+    QModelIndex folderIndex;
+    QmlFolderListModel::SortField sortField;
+    bool sortReversed;
+    int count;
+};
+
+/*!
+    \qmlclass FolderListModel
+    \brief The FolderListModel provides a model of the contents of a folder in a filesystem.
+
+    FolderListModel provides access to the local filesystem.  The \e folder property
+    specifies the folder to list.
+
+    Qt uses "/" as a universal directory separator in the same way that "/" is
+    used as a path separator in URLs. If you always use "/" as a directory
+    separator, Qt will translate your paths to conform to the underlying
+    operating system.
+
+    The roles available are:
+    \list
+    \o fileName
+    \o filePath
+    \endlist
+
+    Additionally a file entry can be differentiated from a folder entry
+    via the \l isFolder() method.
+*/
+
+QmlFolderListModel::QmlFolderListModel(QObject *parent)
+    : QListModelInterface(parent)
+{
+    d = new QmlFolderListModelPrivate;
+    d->model.setFilter(QDir::AllDirs | QDir::Files | QDir::Drives | QDir::NoDotAndDotDot);
+    connect(&d->model, SIGNAL(rowsInserted(const QModelIndex&,int,int))
+            , this, SLOT(inserted(const QModelIndex&,int,int)));
+    connect(&d->model, SIGNAL(rowsRemoved(const QModelIndex&,int,int))
+            , this, SLOT(removed(const QModelIndex&,int,int)));
+    connect(&d->model, SIGNAL(dataChanged(const QModelIndex&,const QModelIndex&))
+            , this, SLOT(dataChanged(const QModelIndex&,const QModelIndex&)));
+    connect(&d->model, SIGNAL(modelReset()), this, SLOT(refresh()));
+    connect(&d->model, SIGNAL(layoutChanged()), this, SLOT(refresh()));
+}
+
+QmlFolderListModel::~QmlFolderListModel()
+{
+    delete d;
+}
+
+QHash<int,QVariant> QmlFolderListModel::data(int index, const QList<int> &roles) const
+{
+    Q_UNUSED(roles);
+    QHash<int,QVariant> folderData;
+    QModelIndex modelIndex = d->model.index(index, 0, d->folderIndex);
+    if (modelIndex.isValid()) {
+        folderData[QDirModel::FileNameRole] = d->model.data(modelIndex, QDirModel::FileNameRole);
+        folderData[QDirModel::FilePathRole] = QUrl::fromLocalFile(d->model.data(modelIndex, QDirModel::FilePathRole).toString());
+    }
+
+    return folderData;
+}
+
+QVariant QmlFolderListModel::data(int index, int role) const
+{
+    QVariant rv;
+    QModelIndex modelIndex = d->model.index(index, 0, d->folderIndex);
+    if (modelIndex.isValid()) {
+        if (role == QDirModel::FileNameRole)
+            rv = d->model.data(modelIndex, QDirModel::FileNameRole);
+        else if (role == QDirModel::FilePathRole)
+            rv = QUrl::fromLocalFile(d->model.data(modelIndex, QDirModel::FilePathRole).toString());
+    }
+
+    return rv;
+}
+
+int QmlFolderListModel::count() const
+{
+    return d->count;
+}
+
+QList<int> QmlFolderListModel::roles() const
+{
+    QList<int> r;
+    r << QDirModel::FileNameRole;
+    r << QDirModel::FilePathRole;
+    return r;
+}
+
+QString QmlFolderListModel::toString(int role) const
+{
+    switch (role) {
+    case QDirModel::FileNameRole:
+        return QLatin1String("fileName");
+    case QDirModel::FilePathRole:
+        return QLatin1String("filePath");
+    }
+
+    return QString();
+}
+
+/*!
+    \qmlproperty string FolderListModel::folder
+
+    The \a folder property holds the folder the model is currently providing.
+
+    It is a URL, but must be a file: or qrc: URL (or relative to such a URL).
+*/
+QUrl QmlFolderListModel::folder() const
+{
+    return d->folder;
+}
+
+void QmlFolderListModel::setFolder(const QUrl &folder)
+{
+    if (folder == d->folder)
+        return;
+    QModelIndex index = d->model.index(folder.toLocalFile());
+    if (index.isValid() && d->model.isDir(index)) {
+        d->folder = folder;
+        QMetaObject::invokeMethod(this, "refresh", Qt::QueuedConnection);
+        emit folderChanged();
+    }
+}
+
+QUrl QmlFolderListModel::parentFolder() const
+{
+    QUrl r;
+    QString localFile = d->folder.toLocalFile();
+    if (!localFile.isEmpty()) {
+        QDir dir(localFile);
+#if defined(Q_OS_SYMBIAN)
+        if (dir.isRoot())
+            dir.setPath("");
+        else
+#endif
+            dir.cdUp();
+        r = d->folder;
+        r.setPath(dir.path());
+    } else {
+        int pos = d->folder.path().lastIndexOf(QLatin1Char('/'));
+        if (pos == -1)
+            return QUrl();
+        r = d->folder;
+        r.setPath(d->folder.path().left(pos));
+    }
+    return r;
+}
+
+/*!
+    \qmlproperty list<string> FolderListModel::nameFilters
+
+    The \a nameFilters property contains a list of filename filters.
+    The filters may include the ? and * wildcards.
+
+    The example below filters on PNG and JPEG files:
+
+    \code
+    FolderListModel {
+        nameFilters: [ "*.png", "*.jpg" ]
+    }
+    \endcode
+*/
+QStringList QmlFolderListModel::nameFilters() const
+{
+    return d->nameFilters;
+}
+
+void QmlFolderListModel::setNameFilters(const QStringList &filters)
+{
+    d->nameFilters = filters;
+    d->model.setNameFilters(d->nameFilters);
+}
+
+void QmlFolderListModel::componentComplete()
+{
+    if (!d->folder.isValid() || !QDir().exists(d->folder.toLocalFile()))
+        setFolder(QUrl(QLatin1String("file://")+QDir::currentPath()));
+
+    if (!d->folderIndex.isValid())
+        QMetaObject::invokeMethod(this, "refresh", Qt::QueuedConnection);
+}
+
+QmlFolderListModel::SortField QmlFolderListModel::sortField() const
+{
+    return d->sortField;
+}
+
+void QmlFolderListModel::setSortField(SortField field)
+{
+    if (field != d->sortField) {
+        d->sortField = field;
+        d->updateSorting();
+    }
+}
+
+bool QmlFolderListModel::sortReversed() const
+{
+    return d->sortReversed;
+}
+
+void QmlFolderListModel::setSortReversed(bool rev)
+{
+    if (rev != d->sortReversed) {
+        d->sortReversed = rev;
+        d->updateSorting();
+    }
+}
+
+/*!
+    \qmlmethod bool FolderListModel::isFolder(int index)
+
+    Returns true if the entry \a index is a folder; otherwise
+    returns false.
+*/
+bool QmlFolderListModel::isFolder(int index) const
+{
+    if (index != -1) {
+        QModelIndex idx = d->model.index(index, 0, d->folderIndex);
+        if (idx.isValid())
+            return d->model.isDir(idx);
+    }
+    return false;
+}
+
+void QmlFolderListModel::refresh()
+{
+    d->folderIndex = QModelIndex();
+    if (d->count) {
+        int tmpCount = d->count;
+        d->count = 0;
+        emit itemsRemoved(0, tmpCount);
+    }
+    d->folderIndex = d->model.index(d->folder.toLocalFile());
+    d->count = d->model.rowCount(d->folderIndex);
+    if (d->count) {
+        emit itemsInserted(0, d->count);
+    }
+}
+
+void QmlFolderListModel::inserted(const QModelIndex &index, int start, int end)
+{
+    if (index == d->folderIndex) {
+        d->count = d->model.rowCount(d->folderIndex);
+        emit itemsInserted(start, end - start + 1);
+    }
+}
+
+void QmlFolderListModel::removed(const QModelIndex &index, int start, int end)
+{
+    if (index == d->folderIndex) {
+        d->count = d->model.rowCount(d->folderIndex);
+        emit itemsRemoved(start, end - start + 1);
+    }
+}
+
+void QmlFolderListModel::dataChanged(const QModelIndex &start, const QModelIndex &end)
+{
+    qDebug() << "data changed";
+    if (start.parent() == d->folderIndex)
+        emit itemsChanged(start.row(), end.row() - start.row() + 1, roles());
+}
+
+/*!
+    \qmlproperty bool FolderListModel::showDirs
+
+    If true (the default), directories are included in the model.
+
+    Note that the nameFilters are ignored for directories.
+*/
+bool QmlFolderListModel::showDirs() const
+{
+    return d->model.filter() & QDir::AllDirs;
+}
+
+void  QmlFolderListModel::setShowDirs(bool on)
+{
+    if (!(d->model.filter() & QDir::AllDirs) == !on)
+        return;
+    if (on)
+        d->model.setFilter(d->model.filter() | QDir::AllDirs | QDir::Drives);
+    else
+        d->model.setFilter(d->model.filter() & ~(QDir::AllDirs | QDir::Drives));
+}
+
+/*!
+    \qmlproperty bool FolderListModel::showDotAndDotDot
+
+    If true, the "." and ".." directories are included in the model.
+
+    The default is false.
+*/
+bool QmlFolderListModel::showDotAndDotDot() const
+{
+    return !(d->model.filter() & QDir::NoDotAndDotDot);
+}
+
+void  QmlFolderListModel::setShowDotAndDotDot(bool on)
+{
+    if (!(d->model.filter() & QDir::NoDotAndDotDot) == on)
+        return;
+    if (on)
+        d->model.setFilter(d->model.filter() & ~QDir::NoDotAndDotDot);
+    else
+        d->model.setFilter(d->model.filter() | QDir::NoDotAndDotDot);
+}
+
+/*!
+    \qmlproperty bool FolderListModel::showOnlyReadable
+
+    If true, only readable files and directories are shown.
+
+    The default is false.
+*/
+bool QmlFolderListModel::showOnlyReadable() const
+{
+    return d->model.filter() & QDir::Readable;
+}
+
+void  QmlFolderListModel::setShowOnlyReadable(bool on)
+{
+    if (!(d->model.filter() & QDir::Readable) == !on)
+        return;
+    if (on)
+        d->model.setFilter(d->model.filter() | QDir::Readable);
+    else
+        d->model.setFilter(d->model.filter() & ~QDir::Readable);
+}
+
+
+QML_DEFINE_TYPE(Qt,4,6,FolderListModel,QmlFolderListModel)
+
+QT_END_NAMESPACE
+
diff --git a/tools/qmlviewer/qmlfolderlistmodel.h b/tools/qmlviewer/qmlfolderlistmodel.h
new file mode 100644
index 0000000..7357954
--- /dev/null
+++ b/tools/qmlviewer/qmlfolderlistmodel.h
@@ -0,0 +1,119 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMLFOLDERLISTMODEL_H
+#define QMLFOLDERLISTMODEL_H
+
+#include <qml.h>
+#include "../../src/declarative/3rdparty/qlistmodelinterface_p.h"
+
+class QmlContext;
+class QModelIndex;
+
+class QmlFolderListModelPrivate;
+class QmlFolderListModel : public QListModelInterface, public QmlParserStatus
+{
+    Q_OBJECT
+    Q_INTERFACES(QmlParserStatus)
+
+    Q_PROPERTY(QUrl folder READ folder WRITE setFolder NOTIFY folderChanged)
+    Q_PROPERTY(QUrl parentFolder READ parentFolder NOTIFY folderChanged)
+    Q_PROPERTY(QStringList nameFilters READ nameFilters WRITE setNameFilters)
+    Q_PROPERTY(SortField sortField READ sortField WRITE setSortField)
+    Q_PROPERTY(bool sortReversed READ sortReversed WRITE setSortReversed)
+    Q_PROPERTY(bool showDirs READ showDirs WRITE setShowDirs)
+    Q_PROPERTY(bool showDotAndDotDot READ showDotAndDotDot WRITE setShowDotAndDotDot)
+    Q_PROPERTY(bool showOnlyReadable READ showOnlyReadable WRITE setShowOnlyReadable)
+
+public:
+    QmlFolderListModel(QObject *parent = 0);
+    ~QmlFolderListModel();
+
+    virtual QHash<int,QVariant> data(int index, const QList<int> &roles = (QList<int>())) const;
+    virtual QVariant data(int index, int role) const;
+    virtual int count() const;
+    virtual QList<int> roles() const;
+    virtual QString toString(int role) const;
+
+    QUrl folder() const;
+    void setFolder(const QUrl &folder);
+
+    QUrl parentFolder() const;
+
+    QStringList nameFilters() const;
+    void setNameFilters(const QStringList &filters);
+
+    virtual void componentComplete();
+
+    Q_INVOKABLE bool isFolder(int index) const;
+
+    enum SortField { Unsorted, Name, Time, Size, Type };
+    SortField sortField() const;
+    void setSortField(SortField field);
+    Q_ENUMS(SortField)
+
+    bool sortReversed() const;
+    void setSortReversed(bool rev);
+
+    bool showDirs() const;
+    void  setShowDirs(bool);
+    bool showDotAndDotDot() const;
+    void  setShowDotAndDotDot(bool);
+    bool showOnlyReadable() const;
+    void  setShowOnlyReadable(bool);
+
+Q_SIGNALS:
+    void folderChanged();
+
+private Q_SLOTS:
+    void refresh();
+    void inserted(const QModelIndex &index, int start, int end);
+    void removed(const QModelIndex &index, int start, int end);
+    void dataChanged(const QModelIndex &start, const QModelIndex &end);
+
+private:
+    Q_DISABLE_COPY(QmlFolderListModel)
+    QmlFolderListModelPrivate *d;
+};
+
+QML_DECLARE_TYPE(QmlFolderListModel)
+
+#endif // QMLFOLDERLISTMODEL_H
diff --git a/tools/qmlviewer/qmlviewer.cpp b/tools/qmlviewer/qmlviewer.cpp
new file mode 100644
index 0000000..2b69d97
--- /dev/null
+++ b/tools/qmlviewer/qmlviewer.cpp
@@ -0,0 +1,1452 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qmlview.h>
+#include "ui_recopts.h"
+
+#include "qmlviewer.h"
+#include <qmlcontext.h>
+#include <qmlengine.h>
+#include <qmlnetworkaccessmanagerfactory.h>
+#include "qml.h"
+#include <private/qperformancelog_p_p.h>
+#include <private/qabstractanimation_p.h>
+#include <QAbstractAnimation>
+#include "deviceskin.h"
+
+#if (QT_VERSION >= QT_VERSION_CHECK(4, 6, 2))
+#include <private/qzipreader_p.h>
+#endif
+
+#include <QSettings>
+#include <QXmlStreamReader>
+#include <QBuffer>
+#include <QNetworkReply>
+#include <QNetworkCookieJar>
+#include <QNetworkDiskCache>
+#include <QNetworkAccessManager>
+#include <QSignalMapper>
+#include <QmlComponent>
+#include <QWidget>
+#include <QApplication>
+#include <QDir>
+#include <QTextBrowser>
+#include <QFile>
+#include <QFileInfo>
+#include <QVBoxLayout>
+#include <QProgressDialog>
+#include <QProcess>
+#include <QMenuBar>
+#include <QMenu>
+#include <QAction>
+#include <QFileDialog>
+#include <QTimer>
+#include <QNetworkProxyFactory>
+#include <QKeyEvent>
+#include <QMutex>
+#include <QMutexLocker>
+#include "proxysettings.h"
+#include "deviceorientation.h"
+
+#ifdef GL_SUPPORTED
+#include <QGLWidget>
+#endif
+
+#include <qfxtester.h>
+
+#if defined (Q_OS_SYMBIAN)
+#define SYMBIAN_NETWORK_INIT
+#endif
+
+#if defined (SYMBIAN_NETWORK_INIT)
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <QTextCodec>
+#include "sym_iap_util.h"
+#endif
+
+QT_BEGIN_NAMESPACE
+
+
+class Screen : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(Orientation orientation READ orientation NOTIFY orientationChanged)
+    Q_ENUMS(Orientation)
+
+public:
+    Screen(QObject *parent=0) : QObject(parent) {
+        connect(DeviceOrientation::instance(), SIGNAL(orientationChanged()),
+                this, SIGNAL(orientationChanged()));
+    }
+
+    enum Orientation { UnknownOrientation = DeviceOrientation::UnknownOrientation,
+                       Portrait = DeviceOrientation::Portrait,
+                       Landscape = DeviceOrientation::Landscape };
+    Orientation orientation() const { return Orientation(DeviceOrientation::instance()->orientation()); }
+
+signals:
+    void orientationChanged();
+};
+
+QML_DECLARE_TYPE(Screen)
+QML_DEFINE_TYPE(QmlViewer, 1, 0, Screen, Screen)
+
+class SizedMenuBar : public QMenuBar
+{
+    Q_OBJECT
+public:
+    SizedMenuBar(QWidget *parent, QWidget *referenceWidget)
+        : QMenuBar(parent), refWidget(referenceWidget)
+    {
+    }
+
+    virtual QSize sizeHint() const
+    {
+        return QSize(refWidget->sizeHint().width(), QMenuBar::sizeHint().height());
+    }
+
+private:
+    QWidget *refWidget;
+};
+
+
+class PreviewDeviceSkin : public DeviceSkin
+{
+    Q_OBJECT
+public:
+    explicit PreviewDeviceSkin(const DeviceSkinParameters &parameters, QWidget *parent);
+
+    void setPreview(QWidget *formWidget);
+    void setPreviewAndScale(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);
+        QApplication::syncX();
+    }
+
+    QSize standardScreenSize() const { return m_screenSize; }
+
+    QMenu* menu;
+
+private slots:
+    void slotSkinKeyPressEvent(int code, const QString& text, bool autorep);
+    void slotSkinKeyReleaseEvent(int code, const QString& text, bool autorep);
+    void slotPopupMenu();
+
+private:
+    const QSize m_screenSize;
+};
+
+
+PreviewDeviceSkin::PreviewDeviceSkin(const DeviceSkinParameters &parameters, QWidget *parent) :
+    DeviceSkin(parameters, parent),
+    m_screenSize(parameters.screenSize())
+{
+    menu = new QMenu(this);
+    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::setPreviewAndScale(QWidget *formWidget)
+{
+    setScreenSize(formWidget->sizeHint());
+    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()
+{
+    menu->exec(QCursor::pos());
+}
+
+static struct { const char *name, *args; } ffmpegprofiles[] = {
+    {"Maximum Quality", "-sameq"},
+    {"High Quality", "-qmax 2"},
+    {"Medium Quality", "-qmax 6"},
+    {"Low Quality", "-qmax 16"},
+    {"Custom ffmpeg arguments", ""},
+    {0,0}
+};
+
+class RecordingDialog : public QDialog, public Ui::RecordingOptions {
+    Q_OBJECT
+
+public:
+    RecordingDialog(QWidget *parent) : QDialog(parent)
+    {
+        setupUi(this);
+        hz->setValidator(new QDoubleValidator(hz));
+        for (int i=0; ffmpegprofiles[i].name; ++i) {
+            profile->addItem(ffmpegprofiles[i].name);
+        }
+    }
+
+    void setArguments(QString a)
+    {
+        int i;
+        for (i=0; ffmpegprofiles[i].args[0]; ++i) {
+            if (ffmpegprofiles[i].args == a) {
+                profile->setCurrentIndex(i);
+                args->setText(QLatin1String(ffmpegprofiles[i].args));
+                return;
+            }
+        }
+        customargs = a;
+        args->setText(a);
+        profile->setCurrentIndex(i);
+    }
+
+    QString arguments() const
+    {
+        int i = profile->currentIndex();
+        return ffmpegprofiles[i].args[0] ? QLatin1String(ffmpegprofiles[i].args) : customargs;
+    }
+
+private slots:
+    void pickProfile(int i)
+    {
+        if (ffmpegprofiles[i].args[0]) {
+            args->setText(QLatin1String(ffmpegprofiles[i].args));
+        } else {
+            args->setText(customargs);
+        }
+    }
+
+    void storeCustomArgs(QString s)
+    {
+        setArguments(s);
+    }
+
+private:
+    QString customargs;
+};
+
+class PersistentCookieJar : public QNetworkCookieJar {
+public:
+    PersistentCookieJar(QObject *parent) : QNetworkCookieJar(parent) { load(); }
+    ~PersistentCookieJar() { save(); }
+
+    virtual QList<QNetworkCookie> cookiesForUrl(const QUrl &url) const
+    {
+        QMutexLocker lock(&mutex);
+        return QNetworkCookieJar::cookiesForUrl(url);
+    }
+
+    virtual bool setCookiesFromUrl(const QList<QNetworkCookie> &cookieList, const QUrl &url)
+    {
+        QMutexLocker lock(&mutex);
+        return QNetworkCookieJar::setCookiesFromUrl(cookieList, url);
+    }
+
+private:
+    void save()
+    {
+        QMutexLocker lock(&mutex);
+        QList<QNetworkCookie> list = allCookies();
+        QByteArray data;
+        foreach (QNetworkCookie cookie, list) {
+            if (!cookie.isSessionCookie()) {
+                data.append(cookie.toRawForm());
+                data.append("\n");
+            }
+        }
+        QSettings settings("Nokia", "QtQmlViewer");
+        settings.setValue("Cookies",data);
+    }
+
+    void load()
+    {
+        QMutexLocker lock(&mutex);
+        QSettings settings("Nokia", "QtQmlViewer");
+        QByteArray data = settings.value("Cookies").toByteArray();
+        setAllCookies(QNetworkCookie::parseCookies(data));
+    }
+
+    mutable QMutex mutex;
+};
+
+class NetworkAccessManagerFactory : public QmlNetworkAccessManagerFactory
+{
+public:
+    NetworkAccessManagerFactory() : cookieJar(0), cacheSize(0) {}
+
+    QNetworkAccessManager *create(QObject *parent) {
+        QMutexLocker lock(&mutex);
+        QNetworkAccessManager *manager = new QNetworkAccessManager(parent);
+        if (!cookieJar)
+            cookieJar = new PersistentCookieJar(manager);
+        manager->setCookieJar(cookieJar);
+        cookieJar->setParent(0);
+        setupProxy(manager);
+        if (cacheSize > 0) {
+            QNetworkDiskCache *cache = new QNetworkDiskCache;
+            cache->setCacheDirectory(QDir::tempPath()+QLatin1String("/qml-duiviewer-network-cache"));
+            cache->setMaximumCacheSize(cacheSize);
+            manager->setCache(cache);
+        } else {
+            manager->setCache(0);
+        }
+        qDebug() << "created new manager for" << parent;
+        return manager;
+    }
+
+    void setupProxy(QNetworkAccessManager *nam)
+    {
+        class SystemProxyFactory : public QNetworkProxyFactory
+        {
+        public:
+            virtual QList<QNetworkProxy> queryProxy(const QNetworkProxyQuery &query)
+            {
+                QString protocolTag = query.protocolTag();
+                if (httpProxyInUse && (protocolTag == "http" || protocolTag == "https")) {
+                    QList<QNetworkProxy> ret;
+                    ret << httpProxy;
+                    return ret;
+                }
+                return QNetworkProxyFactory::systemProxyForQuery(query);
+            }
+            void setHttpProxy (QNetworkProxy proxy)
+            {
+                httpProxy = proxy;
+                httpProxyInUse = true;
+            }
+            void unsetHttpProxy ()
+            {
+                httpProxyInUse = false;
+            }
+        private:
+            bool httpProxyInUse;
+            QNetworkProxy httpProxy;
+        };
+
+        SystemProxyFactory *proxyFactory = new SystemProxyFactory;
+        if (ProxySettings::httpProxyInUse())
+            proxyFactory->setHttpProxy(ProxySettings::httpProxy());
+        else
+            proxyFactory->unsetHttpProxy();
+        nam->setProxyFactory(proxyFactory);
+    }
+
+    void setCacheSize(int size) {
+        if (size != cacheSize) {
+            cacheSize = size;
+        }
+    }
+
+    PersistentCookieJar *cookieJar;
+    QMutex mutex;
+    int cacheSize;
+};
+
+
+QString QmlViewer::getVideoFileName()
+{
+    QString title = convertAvailable || ffmpegAvailable ? tr("Save Video File") : tr("Save PNG Frames");
+    QStringList types;
+    if (ffmpegAvailable) types += tr("Common Video files")+QLatin1String(" (*.avi *.mpeg *.mov)");
+    if (convertAvailable) types += tr("GIF Animation")+QLatin1String(" (*.gif)");
+    types += tr("Individual PNG frames")+QLatin1String(" (*.png)");
+    if (ffmpegAvailable) types += tr("All ffmpeg formats (*.*)");
+    return QFileDialog::getSaveFileName(this, title, "", types.join(";; "));
+}
+
+
+QmlViewer::QmlViewer(QWidget *parent, Qt::WindowFlags flags)
+#if defined(Q_OS_SYMBIAN)
+    : QMainWindow(parent, flags)
+#else
+    : QWidget(parent, flags)
+#endif
+      , frame_stream(0), scaleSkin(true), mb(0)
+      , portraitOrientation(0), landscapeOrientation(0)
+      , m_scriptOptions(0), tester(0), useQmlFileBrowser(true)
+{
+    devicemode = false;
+    skin = 0;
+    canvas = 0;
+    record_autotime = 0;
+    record_rate = 50;
+    record_args += QLatin1String("-sameq");
+
+    recdlg = new RecordingDialog(this);
+    connect(recdlg->pickfile, SIGNAL(clicked()), this, SLOT(pickRecordingFile()));
+    senseFfmpeg();
+    senseImageMagick();
+    if (!ffmpegAvailable)
+        recdlg->ffmpegOptions->hide();
+    if (!ffmpegAvailable && !convertAvailable)
+        recdlg->rateOptions->hide();
+    QString warn;
+    if (!ffmpegAvailable) {
+        if (!convertAvailable)
+            warn = tr("ffmpeg and ImageMagick not available - no video output");
+        else
+            warn = tr("ffmpeg not available - GIF and PNG outputs only");
+        recdlg->warning->setText(warn);
+    } else {
+        recdlg->warning->hide();
+    }
+
+    canvas = new QmlView(this);
+    canvas->setAttribute(Qt::WA_OpaquePaintEvent);
+    canvas->setAttribute(Qt::WA_NoSystemBackground);
+    canvas->setContentResizable(!skin || !scaleSkin);
+    canvas->setFocus();
+
+    QObject::connect(canvas, SIGNAL(sceneResized(QSize)), this, SLOT(sceneResized(QSize)));
+    QObject::connect(canvas, SIGNAL(initialSize(QSize)), this, SLOT(adjustSizeSlot()));
+    QObject::connect(canvas, SIGNAL(errors(QList<QmlError>)), this, SLOT(executeErrors()));
+    QObject::connect(canvas, SIGNAL(quit()), QCoreApplication::instance (), SLOT(quit()));
+
+    if (!(flags & Qt::FramelessWindowHint)) {
+        createMenu(menuBar(),0);
+        setPortrait();
+    }
+
+#if !defined(Q_OS_SYMBIAN)
+    QVBoxLayout *layout = new QVBoxLayout;
+    layout->setMargin(0);
+    layout->setSpacing(0);
+    setLayout(layout);
+    if (mb)
+        layout->addWidget(mb);
+    layout->addWidget(canvas);
+#else
+    setCentralWidget(canvas);
+#endif
+
+    namFactory = new NetworkAccessManagerFactory;
+    canvas->engine()->setNetworkAccessManagerFactory(namFactory);
+
+    connect(&autoStartTimer, SIGNAL(triggered()), this, SLOT(autoStartRecording()));
+    connect(&autoStopTimer, SIGNAL(triggered()), this, SLOT(autoStopRecording()));
+    connect(&recordTimer, SIGNAL(triggered()), this, SLOT(recordFrame()));
+    autoStartTimer.setRunning(false);
+    autoStopTimer.setRunning(false);
+    recordTimer.setRunning(false);
+    recordTimer.setRepeating(true);
+}
+
+QmlViewer::~QmlViewer()
+{
+    canvas->engine()->setNetworkAccessManagerFactory(0);
+    delete namFactory;
+}
+
+void QmlViewer::adjustSizeSlot()
+{
+    resize(sizeHint());
+}
+
+QMenuBar *QmlViewer::menuBar() const
+{
+#if !defined(Q_OS_SYMBIAN)
+    if (!mb)
+        mb = new SizedMenuBar((QWidget*)this, canvas);
+#else
+    mb = QMainWindow::menuBar();
+#endif
+
+    return mb;
+}
+
+void QmlViewer::createMenu(QMenuBar *menu, QMenu *flatmenu)
+{
+    QObject *parent = flatmenu ? (QObject*)flatmenu : (QObject*)menu;
+
+    QMenu *fileMenu = flatmenu ? flatmenu : menu->addMenu(tr("&File"));
+
+    QAction *openAction = new QAction(tr("&Open..."), parent);
+    openAction->setShortcut(QKeySequence("Ctrl+O"));
+    connect(openAction, SIGNAL(triggered()), this, SLOT(openFile()));
+    fileMenu->addAction(openAction);
+
+    QAction *reloadAction = new QAction(tr("&Reload"), parent);
+    reloadAction->setShortcut(QKeySequence("Ctrl+R"));
+    connect(reloadAction, SIGNAL(triggered()), this, SLOT(reload()));
+    fileMenu->addAction(reloadAction);
+
+#if defined(Q_OS_SYMBIAN)
+    QAction *networkAction = new QAction(tr("Start &Network"), parent);
+    connect(networkAction, SIGNAL(triggered()), this, SLOT(startNetwork()));
+    fileMenu->addAction(networkAction);
+#endif
+
+#if !defined(Q_OS_SYMBIAN)
+    if (flatmenu) flatmenu->addSeparator();
+
+    QMenu *recordMenu = flatmenu ? flatmenu : menu->addMenu(tr("&Recording"));
+
+    QAction *snapshotAction = new QAction(tr("&Take Snapshot\tF3"), parent);
+    connect(snapshotAction, SIGNAL(triggered()), this, SLOT(takeSnapShot()));
+    recordMenu->addAction(snapshotAction);
+
+    recordAction = new QAction(tr("Start Recording &Video\tF9"), parent);
+    connect(recordAction, SIGNAL(triggered()), this, SLOT(toggleRecordingWithSelection()));
+    recordMenu->addAction(recordAction);
+
+    QAction *recordOptions = new QAction(tr("Video &Options..."), parent);
+    connect(recordOptions, SIGNAL(triggered()), this, SLOT(chooseRecordingOptions()));
+
+    if (flatmenu)
+        flatmenu->addAction(recordOptions);
+
+    if (flatmenu) flatmenu->addSeparator();
+
+    QMenu *debugMenu = flatmenu ? flatmenu->addMenu(tr("&Debugging")) : menu->addMenu(tr("&Debugging"));
+
+    QAction *slowAction = new QAction(tr("&Slow Down Animations"), parent);
+    slowAction->setShortcut(QKeySequence("Ctrl+."));
+    slowAction->setCheckable(true);
+    connect(slowAction, SIGNAL(triggered(bool)), this, SLOT(setSlowMode(bool)));
+    debugMenu->addAction(slowAction);
+
+    if (flatmenu) flatmenu->addSeparator();
+
+    QMenu *skinMenu = flatmenu ? flatmenu->addMenu(tr("&Skin")) : menu->addMenu(tr("&Skin"));
+
+    QActionGroup *skinActions;
+    QAction *skinAction;
+
+    skinActions = new QActionGroup(parent);
+    skinAction = new QAction(tr("Scale skin"), parent);
+    skinAction->setCheckable(true);
+    skinAction->setChecked(scaleSkin);
+    skinActions->addAction(skinAction);
+    skinMenu->addAction(skinAction);
+    connect(skinAction, SIGNAL(triggered()), this, SLOT(setScaleSkin()));
+    skinAction = new QAction(tr("Resize view"), parent);
+    skinAction->setCheckable(true);
+    skinAction->setChecked(!scaleSkin);
+    skinActions->addAction(skinAction);
+    skinMenu->addAction(skinAction);
+    connect(skinAction, SIGNAL(triggered()), this, SLOT(setScaleView()));
+    skinMenu->addSeparator();
+
+    skinActions = new QActionGroup(parent);
+    QSignalMapper *mapper = new QSignalMapper(parent);
+    skinAction = new QAction(tr("None"), parent);
+    skinAction->setCheckable(true);
+    if (currentSkin.isEmpty())
+        skinAction->setChecked(true);
+    skinActions->addAction(skinAction);
+    skinMenu->addAction(skinAction);
+    mapper->setMapping(skinAction, "");
+    connect(skinAction, SIGNAL(triggered()), mapper, SLOT(map()));
+    skinMenu->addSeparator();
+
+    foreach (QString name, builtinSkins()) {
+        skinAction = new QAction(name, parent);
+        skinActions->addAction(skinAction);
+        skinMenu->addAction(skinAction);
+        skinAction->setCheckable(true);
+        if (":skin/"+name+".skin" == currentSkin)
+            skinAction->setChecked(true);
+        mapper->setMapping(skinAction, name);
+        connect(skinAction, SIGNAL(triggered()), mapper, SLOT(map()));
+    }
+    connect(mapper, SIGNAL(mapped(QString)), this, SLOT(setSkin(QString)));
+
+    if (flatmenu) flatmenu->addSeparator();
+#endif // Q_OS_SYMBIAN
+
+    QMenu *settingsMenu = flatmenu ? flatmenu : menu->addMenu(tr("S&ettings"));
+    QAction *proxyAction = new QAction(tr("Http &proxy..."), parent);
+    connect(proxyAction, SIGNAL(triggered()), this, SLOT(showProxySettings()));
+    settingsMenu->addAction(proxyAction);
+#if !defined(Q_OS_SYMBIAN)
+    if (!flatmenu)
+        settingsMenu->addAction(recordOptions);
+#else
+    QAction *fullscreenAction = new QAction(tr("Full Screen"), parent);
+    fullscreenAction->setCheckable(true);
+    connect(fullscreenAction, SIGNAL(triggered()), this, SLOT(toggleFullScreen()));
+    settingsMenu->addAction(fullscreenAction);
+#endif
+
+    QMenu *propertiesMenu = settingsMenu->addMenu(tr("Properties"));
+    QActionGroup *orientation = new QActionGroup(parent);
+
+    QAction *toggleOrientation = new QAction(tr("&Toggle Orientation"), parent);
+    toggleOrientation->setCheckable(true);
+    toggleOrientation->setShortcut(QKeySequence("Ctrl+T"));
+    settingsMenu->addAction(toggleOrientation);
+    connect(toggleOrientation, SIGNAL(triggered()), this, SLOT(toggleOrientation()));
+
+    orientation->setExclusive(true);
+    portraitOrientation = new QAction(tr("orientation: Portrait"), parent);
+    portraitOrientation->setCheckable(true);
+    connect(portraitOrientation, SIGNAL(triggered()), this, SLOT(setPortrait()));
+    orientation->addAction(portraitOrientation);
+    propertiesMenu->addAction(portraitOrientation);
+
+    landscapeOrientation = new QAction(tr("orientation: Landscape"), parent);
+    landscapeOrientation->setCheckable(true);
+    connect(landscapeOrientation, SIGNAL(triggered()), this, SLOT(setLandscape()));
+    orientation->addAction(landscapeOrientation);
+    propertiesMenu->addAction(landscapeOrientation);
+
+    if (flatmenu) flatmenu->addSeparator();
+
+    QMenu *helpMenu = flatmenu ? flatmenu : menu->addMenu(tr("&Help"));
+    QAction *aboutAction = new QAction(tr("&About Qt..."), parent);
+    connect(aboutAction, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
+    helpMenu->addAction(aboutAction);
+
+    QAction *quitAction = new QAction(tr("&Quit"), parent);
+    quitAction->setShortcut(QKeySequence("Ctrl+Q"));
+    connect(quitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
+    fileMenu->addSeparator();
+    fileMenu->addAction(quitAction);
+    if (menu) {
+        menu->setFixedHeight(menu->sizeHint().height());
+        menu->setMinimumWidth(10);
+    }
+}
+
+void QmlViewer::showProxySettings()
+{
+    ProxySettings settingsDlg (this);
+
+    connect (&settingsDlg, SIGNAL (accepted()), this, SLOT (proxySettingsChanged ()));
+
+    settingsDlg.exec();
+}
+
+void QmlViewer::proxySettingsChanged()
+{
+    reload ();
+}
+
+void QmlViewer::setPortrait()
+{
+    DeviceOrientation::instance()->setOrientation(DeviceOrientation::Portrait);
+    portraitOrientation->setChecked(true);
+}
+
+void QmlViewer::setLandscape()
+{
+    DeviceOrientation::instance()->setOrientation(DeviceOrientation::Landscape);
+    landscapeOrientation->setChecked(true);
+}
+
+void QmlViewer::toggleOrientation()
+{
+    DeviceOrientation::instance()->setOrientation(DeviceOrientation::instance()->orientation()==DeviceOrientation::Portrait?DeviceOrientation::Landscape:DeviceOrientation::Portrait);
+}
+
+void QmlViewer::toggleFullScreen()
+{
+    if (isFullScreen())
+        showMaximized();
+    else
+        showFullScreen();
+}
+
+void QmlViewer::setScaleSkin()
+{
+    if (scaleSkin)
+        return;
+    scaleSkin = true;
+    canvas->setContentResizable(!skin || !scaleSkin);
+    if (skin) {
+        canvas->setFixedSize(canvas->sizeHint());
+        skin->setScreenSize(canvas->sizeHint());
+    }
+}
+
+void QmlViewer::setScaleView()
+{
+    if (!scaleSkin)
+        return;
+    scaleSkin = false;
+    if (skin) {
+        canvas->setContentResizable(!skin || !scaleSkin);
+        canvas->setMinimumSize(QSize(0,0));
+        canvas->setMaximumSize(QSize(16777215,16777215));
+        canvas->resize(skin->standardScreenSize());
+        skin->setScreenSize(skin->standardScreenSize());
+    }
+}
+
+
+void QmlViewer::takeSnapShot()
+{
+    static int snapshotcount = 1;
+    QString snapFileName = QString(QLatin1String("snapshot%1.png")).arg(snapshotcount);
+    QPixmap::grabWidget(canvas).save(snapFileName);
+    qDebug() << "Wrote" << snapFileName;
+    ++snapshotcount;
+}
+
+void QmlViewer::pickRecordingFile()
+{
+    QString fileName = getVideoFileName();
+    if (!fileName.isEmpty())
+        recdlg->file->setText(fileName);
+}
+
+void QmlViewer::chooseRecordingOptions()
+{
+    // File
+    recdlg->file->setText(record_file);
+
+    // Size
+    recdlg->sizeOriginal->setText(tr("Original (%1x%2)").arg(canvas->width()).arg(canvas->height()));
+    if (recdlg->sizeWidth->value()<=1) {
+        recdlg->sizeWidth->setValue(canvas->width());
+        recdlg->sizeHeight->setValue(canvas->height());
+    }
+
+    // Rate
+    if (record_rate == 24)
+        recdlg->hz24->setChecked(true);
+    else if (record_rate == 25)
+        recdlg->hz25->setChecked(true);
+    else if (record_rate == 50)
+        recdlg->hz50->setChecked(true);
+    else if (record_rate == 60)
+        recdlg->hz60->setChecked(true);
+    else {
+        recdlg->hzCustom->setChecked(true);
+        recdlg->hz->setText(QString::number(record_rate));
+    }
+
+    // Profile
+    recdlg->setArguments(record_args.join(" "));
+    if (recdlg->exec()) {
+        // File
+        record_file = recdlg->file->text();
+        // Size
+        if (recdlg->sizeOriginal->isChecked())
+            record_outsize = QSize();
+        else if (recdlg->size720p->isChecked())
+            record_outsize = QSize(1280,720);
+        else if (recdlg->sizeVGA->isChecked())
+            record_outsize = QSize(640,480);
+        else if (recdlg->sizeQVGA->isChecked())
+            record_outsize = QSize(320,240);
+        else
+            record_outsize = QSize(recdlg->sizeWidth->value(),recdlg->sizeHeight->value());
+        // Rate
+        if (recdlg->hz24->isChecked())
+            record_rate = 24;
+        else if (recdlg->hz25->isChecked())
+            record_rate = 25;
+        else if (recdlg->hz50->isChecked())
+            record_rate = 50;
+        else if (recdlg->hz60->isChecked())
+            record_rate = 60;
+        else {
+            record_rate = recdlg->hz->text().toDouble();
+        }
+        // Profile
+        record_args = recdlg->arguments().split(" ",QString::SkipEmptyParts);
+    }
+}
+
+void QmlViewer::toggleRecordingWithSelection()
+{
+    if (!recordTimer.isRunning()) {
+        if (record_file.isEmpty()) {
+            QString fileName = getVideoFileName();
+            if (fileName.isEmpty())
+                return;
+            if (!fileName.contains(QRegExp(".[^\\/]*$")))
+                fileName += ".avi";
+            setRecordFile(fileName);
+        }
+    }
+    toggleRecording();
+}
+
+void QmlViewer::toggleRecording()
+{
+    if (record_file.isEmpty()) {
+        toggleRecordingWithSelection();
+        return;
+    }
+    bool recording = !recordTimer.isRunning();
+    recordAction->setText(recording ? tr("&Stop Recording Video\tF9") : tr("&Start Recording Video\tF9"));
+    setRecording(recording);
+}
+
+void QmlViewer::setSlowMode(bool enable)
+{
+    QUnifiedTimer::instance()->setSlowModeEnabled(enable);
+}
+
+void QmlViewer::addLibraryPath(const QString& lib)
+{
+    canvas->engine()->addImportPath(lib);
+}
+
+void QmlViewer::reload()
+{
+    openQml(currentFileOrUrl);
+}
+
+void QmlViewer::open(const QString& doc)
+{
+#if (QT_VERSION >= QT_VERSION_CHECK(4, 6, 2))
+    if (doc.endsWith(".wgt",Qt::CaseInsensitive)
+     || doc.endsWith(".wgz",Qt::CaseInsensitive)
+     || doc.endsWith(".zip",Qt::CaseInsensitive))
+        openWgt(doc);
+    else
+#endif
+        openQml(doc);
+}
+
+void QmlViewer::openWgt(const QString& doc)
+{
+#if (QT_VERSION >= QT_VERSION_CHECK(4, 6, 2))
+    // XXX This functionality could be migrated to QmlView once refined
+
+    QUrl url(doc);
+    if (url.isRelative())
+        url = QUrl::fromLocalFile(doc);
+    canvas->reset();
+    QNetworkAccessManager * nam = canvas->engine()->networkAccessManager();
+    wgtreply = nam->get(QNetworkRequest(url));
+    connect(wgtreply,SIGNAL(finished()),this,SLOT(unpackWgt()));
+#endif
+}
+
+#if (QT_VERSION >= QT_VERSION_CHECK(4, 6, 2))
+static void removeRecursive(const QString& dirname)
+{
+    QDir dir(dirname);
+    QFileInfoList entries(dir.entryInfoList(QDir::Dirs|QDir::Files|QDir::NoDotAndDotDot));
+    for (int i = 0; i < entries.count(); ++i)
+        if (entries[i].isDir())
+            removeRecursive(entries[i].filePath());
+        else
+            dir.remove(entries[i].fileName());
+    QDir().rmdir(dirname);
+}
+#endif
+
+void QmlViewer::unpackWgt()
+{
+#if (QT_VERSION >= QT_VERSION_CHECK(4, 6, 2))
+    QByteArray all = wgtreply->readAll();
+    QBuffer buf(&all);
+    buf.open(QIODevice::ReadOnly);
+    QZipReader zip(&buf);
+    /*
+    for (int i=0; i<zip.count(); ++i) {
+        QZipReader::FileInfo info = zip.entryInfoAt(i);
+        qDebug() << "zip:" << info.filePath;
+    }
+    */
+    wgtdir = QDir::tempPath()+QDir::separator()+QLatin1String("qmlviewer-wgt");
+    removeRecursive(wgtdir);
+    QDir().mkpath(wgtdir);
+    zip.extractAll(wgtdir);
+
+    QString rootfile;
+
+    if (wgtreply->header(QNetworkRequest::ContentTypeHeader).toString() == "application/widget" || wgtreply->url().path().endsWith(".wgt",Qt::CaseInsensitive)) {
+        // W3C Draft http://www.w3.org/TR/2009/CR-widgets-20091201
+        QFile configfile(wgtdir+QDir::separator()+"config.xml");
+        if (configfile.open(QIODevice::ReadOnly)) {
+            QXmlStreamReader config(&configfile);
+            if (config.readNextStartElement() && config.name() == "widget") {
+                while (config.readNextStartElement()) {
+                    if (config.name() == "content") {
+                        rootfile = wgtdir + QDir::separator();
+                        rootfile += config.attributes().value(QLatin1String("src"));
+                    }
+                    // XXX process other config
+
+                    config.skipCurrentElement();
+                }
+            }
+        } else {
+            qWarning("No config.xml found - non-standard WGT file");
+        }
+        if (rootfile.isEmpty()) {
+            QString def = wgtdir+QDir::separator()+"index.qml";
+            if (QFile::exists(def))
+                rootfile = def;
+        }
+    } else {
+        // Just find index.qml, preferably at the root
+        for (int i=0; i<zip.count(); ++i) {
+            QZipReader::FileInfo info = zip.entryInfoAt(i);
+            if (info.filePath.compare(QLatin1String("index.qml"),Qt::CaseInsensitive)==0)
+                rootfile = wgtdir+QDir::separator()+info.filePath;
+            if (rootfile.isEmpty() && info.filePath.endsWith("/index.qml",Qt::CaseInsensitive))
+                rootfile = wgtdir+QDir::separator()+info.filePath;
+        }
+    }
+
+    openQml(rootfile);
+#endif
+}
+
+void QmlViewer::openFile()
+{
+    QString cur = canvas->url().toLocalFile();
+    if (useQmlFileBrowser) {
+        openQml("qrc:/content/Browser.qml");
+    } else {
+        QString fileName = QFileDialog::getOpenFileName(this, tr("Open QML file"), cur, tr("QML Files (*.qml)"));
+        if (!fileName.isEmpty()) {
+            QFileInfo fi(fileName);
+            openQml(fi.absoluteFilePath());
+        }
+    }
+}
+
+void QmlViewer::executeErrors()
+{
+    if (tester) tester->executefailure();
+}
+
+void QmlViewer::launch(const QString& file_or_url)
+{
+    QMetaObject::invokeMethod(this, "openQml", Qt::QueuedConnection, Q_ARG(QString, file_or_url));
+}
+
+void QmlViewer::openQml(const QString& file_or_url)
+{
+    currentFileOrUrl = file_or_url;
+
+    QUrl url;
+    QFileInfo fi(file_or_url);
+    if (fi.exists())
+        url = QUrl::fromLocalFile(fi.absoluteFilePath());
+    else
+        url = QUrl(file_or_url);
+    setWindowTitle(tr("%1 - Qt Declarative UI Viewer").arg(file_or_url));
+
+    if (!m_script.isEmpty()) 
+        tester = new QmlGraphicsTester(m_script, m_scriptOptions, canvas);
+
+    canvas->reset();
+    QmlContext *ctxt = canvas->rootContext();
+    ctxt->setContextProperty("qmlViewer", this);
+#ifdef Q_OS_SYMBIAN
+    ctxt->setContextProperty("qmlViewerFolder", "E:\\"); // Documents on your S60 phone
+#else
+    ctxt->setContextProperty("qmlViewerFolder", QDir::currentPath());
+#endif
+
+    QString fileName = url.toLocalFile();
+    if (!fileName.isEmpty()) {
+        QFileInfo fi(fileName);
+        if (fi.exists()) {
+            if (fi.suffix().toLower() != QLatin1String("qml")) {
+                qWarning() << "qmlviewer cannot open non-QML file" << fileName;
+                return;
+            }
+
+            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(comp.isError()) {
+                    QList<QmlError> errors = comp.errors();
+                    foreach (const QmlError &error, errors) {
+                        qWarning() << error;
+                    }
+                    if (tester) tester->executefailure();
+                }
+
+                if (dummyData) {
+                    qWarning() << "Loaded dummy data:" << dir.filePath(qml);
+                    qml.truncate(qml.length()-4);
+                    ctxt->setContextProperty(qml, dummyData);
+                    dummyData->setParent(this);
+                }
+            }
+        } else {
+            qWarning() << "qmlviewer cannot find file:" << fileName;
+            return;
+        }
+    }
+
+    canvas->setUrl(url);
+
+    QTime t;
+    t.start();
+    canvas->execute();
+    qWarning() << "Wall startup time:" << t.elapsed();
+
+    if (!skin) {
+        canvas->updateGeometry();
+        if (mb)
+            mb->updateGeometry();
+        if (!isFullScreen() && !isMaximized())
+            resize(sizeHint());
+    } else {
+        if (scaleSkin)
+            canvas->resize(canvas->sizeHint());
+        else {
+            canvas->setFixedSize(skin->standardScreenSize());
+            canvas->resize(skin->standardScreenSize());
+        }
+    }
+
+#ifdef QTOPIA
+    show();
+#endif
+}
+
+void QmlViewer::startNetwork()
+{
+#if defined(SYMBIAN_NETWORK_INIT)
+    qt_SetDefaultIap();
+#endif
+}
+
+QStringList QmlViewer::builtinSkins() const
+{
+    QDir dir(":/skins/","*.skin");
+    const QFileInfoList l = dir.entryInfoList();
+    QStringList r;
+    for (QFileInfoList::const_iterator it = l.begin(); it != l.end(); ++it) {
+        r += (*it).baseName();
+    }
+    return r;
+}
+
+void QmlViewer::setSkin(const QString& skinDirOrName)
+{
+    QString skinDirectory = skinDirOrName;
+
+    if (!QDir(skinDirOrName).exists() && QDir(":/skins/"+skinDirOrName+".skin").exists())
+        skinDirectory = ":/skins/"+skinDirOrName+".skin";
+
+    if (currentSkin == skinDirectory)
+        return;
+
+    currentSkin = skinDirectory;
+
+    // XXX QWidget::setMask does not handle changes well, and we may
+    // XXX have been signalled from an item in a menu we're replacing,
+    // XXX hence some rather convoluted resetting here...
+
+    QString err;
+    if (skin) {
+        skin->hide();
+        skin->deleteLater();
+    }
+
+    canvas->setContentResizable(!skin || !scaleSkin);
+
+    DeviceSkinParameters parameters;
+    if (!skinDirectory.isEmpty() && parameters.read(skinDirectory,DeviceSkinParameters::ReadAll,&err)) {
+        layout()->setEnabled(false);
+        //setMenuBar(0);
+        if (mb)
+            mb->hide();
+        if (!err.isEmpty())
+            qWarning() << err;
+        skin = new PreviewDeviceSkin(parameters,this);
+        canvas->resize(canvas->sizeHint());
+        if (scaleSkin)
+            skin->setPreviewAndScale(canvas);
+        else
+            skin->setPreview(canvas);
+        createMenu(0,skin->menu);
+        skin->show();
+    } else {
+        skin = 0;
+        clearMask();
+        menuBar()->clear();
+        canvas->setParent(this, Qt::SubWindow);
+        createMenu(menuBar(),0);
+        mb->show();
+        setMinimumSize(QSize(0,0));
+        setMaximumSize(QSize(16777215,16777215));
+        canvas->setMinimumSize(QSize(0,0));
+        canvas->setMaximumSize(QSize(16777215,16777215));
+        QRect g = geometry();
+        g.setSize(sizeHint());
+        setParent(0,windowFlags()); // recreate
+        canvas->move(0,menuBar()->sizeHint().height());
+        setGeometry(g);
+        layout()->setEnabled(true);
+        show();
+    }
+    canvas->show();
+}
+
+void QmlViewer::setAutoRecord(int from, int to)
+{
+    if (from==0) from=1; // ensure resized
+    record_autotime = to-from;
+    autoStartTimer.setInterval(from);
+    autoStartTimer.setRunning(true);
+}
+
+void QmlViewer::setRecordArgs(const QStringList& a)
+{
+    record_args = a;
+}
+
+void QmlViewer::setRecordFile(const QString& f)
+{
+    record_file = f;
+}
+
+void QmlViewer::setRecordRate(int fps)
+{
+    record_rate = fps;
+}
+
+void QmlViewer::sceneResized(QSize size)
+{
+    if (size.width() > 0 && size.height() > 0) {
+        if (skin && scaleSkin)
+            skin->setScreenSize(size);
+    }
+}
+
+void QmlViewer::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 - save test script\n"
+                 << "F3 - take PNG snapshot\n"
+                 << "F4 - show items and state\n"
+                 << "F5 - reload QML\n"
+                 << "F6 - show object tree\n"
+                 << "F7 - show timing\n"
+                 << "F8 - show performance (if available)\n"
+                 << "F9 - toggle video recording\n"
+                 << "F10 - toggle orientation\n"
+                 << "device keys: 0=quit, 1..8=F1..F8"
+                ;
+    } else if (event->key() == Qt::Key_F2 || (event->key() == Qt::Key_2 && devicemode)) {
+        if (tester && m_scriptOptions & Record)
+            tester->save();
+    } else if (event->key() == Qt::Key_F3 || (event->key() == Qt::Key_3 && devicemode)) {
+        takeSnapShot();
+    } else if (event->key() == Qt::Key_F5 || (event->key() == Qt::Key_5 && devicemode)) {
+        reload();
+    } else if (event->key() == Qt::Key_F8 || (event->key() == Qt::Key_8 && devicemode)) {
+        QPerformanceLog::displayData();
+        QPerformanceLog::clear();
+    } else if (event->key() == Qt::Key_F9 || (event->key() == Qt::Key_9 && devicemode)) {
+        toggleRecording();
+    } else if (event->key() == Qt::Key_F10) {
+        if (portraitOrientation) {
+            if (portraitOrientation->isChecked())
+                setLandscape();
+            else
+                setPortrait();
+        }
+    }
+
+    QWidget::keyPressEvent(event);
+}
+
+void QmlViewer::senseImageMagick()
+{
+    QProcess proc;
+    proc.start("convert", QStringList() << "-h");
+    proc.waitForFinished(2000);
+    QString help = proc.readAllStandardOutput();
+    convertAvailable = help.contains("ImageMagick");
+}
+
+void QmlViewer::senseFfmpeg()
+{
+    QProcess proc;
+    proc.start("ffmpeg", QStringList() << "-h");
+    proc.waitForFinished(2000);
+    QString ffmpegHelp = proc.readAllStandardOutput();
+    ffmpegAvailable = ffmpegHelp.contains("-s ");
+    ffmpegHelp = tr("Video recording uses ffmpeg:")+"\n\n"+ffmpegHelp;
+
+    QDialog *d = new QDialog(recdlg);
+    QVBoxLayout *l = new QVBoxLayout(d);
+    QTextBrowser *b = new QTextBrowser(d);
+    QFont f = b->font();
+    f.setFamily("courier");
+    b->setFont(f);
+    b->setText(ffmpegHelp);
+    l->addWidget(b);
+    d->setLayout(l);
+    ffmpegHelpWindow = d;
+    connect(recdlg->ffmpegHelp,SIGNAL(clicked()), ffmpegHelpWindow, SLOT(show()));
+}
+
+void QmlViewer::setRecording(bool on)
+{
+    if (on == recordTimer.isRunning())
+        return;
+
+    int period = int(1000/record_rate+0.5);
+    QUnifiedTimer::instance()->setTimingInterval(on ? period:16);
+    QUnifiedTimer::instance()->setConsistentTiming(on);
+    if (on) {
+        canvas->setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
+        recordTimer.setInterval(period);
+        recordTimer.setRunning(true);
+        frame_fmt = record_file.right(4).toLower();
+        frame = QImage(canvas->width(),canvas->height(),QImage::Format_RGB32);
+        if (frame_fmt != ".png" && (!convertAvailable || frame_fmt != ".gif")) {
+            // Stream video to ffmpeg
+
+            QProcess *proc = new QProcess(this);
+            connect(proc, SIGNAL(finished(int)), this, SLOT(ffmpegFinished(int)));
+            frame_stream = proc;
+
+            QStringList args;
+            args << "-y";
+            args << "-r" << QString::number(record_rate);
+            args << "-f" << "rawvideo";
+            args << "-pix_fmt" << (frame_fmt == ".gif" ? "rgb24" : "rgb32");
+            args << "-s" << QString("%1x%2").arg(canvas->width()).arg(canvas->height());
+            args << "-i" << "-";
+            if (record_outsize.isValid()) {
+                args << "-s" << QString("%1x%2").arg(record_outsize.width()).arg(record_outsize.height());
+                args << "-aspect" << QString::number(double(canvas->width())/canvas->height());
+            }
+            args += record_args;
+            args << record_file;
+            proc->start("ffmpeg",args);
+
+        } else {
+            // Store frames, save to GIF/PNG
+            frame_stream = 0;
+        }
+    } else {
+        canvas->setViewportUpdateMode(QGraphicsView::MinimalViewportUpdate);
+        recordTimer.setRunning(false);
+        if (frame_stream) {
+            qDebug() << "Saving video...";
+            frame_stream->close();
+            qDebug() << "Wrote" << record_file;
+        } else {
+            QProgressDialog progress(tr("Saving frames..."), tr("Cancel"), 0, frames.count()+10, this);
+            progress.setWindowModality(Qt::WindowModal);
+
+            int frame=0;
+            QStringList inputs;
+            qDebug() << "Saving frames...";
+
+            QString framename;
+            bool png_output = false;
+            if (record_file.right(4).toLower()==".png") {
+                if (record_file.contains('%'))
+                    framename = record_file;
+                else
+                    framename = record_file.left(record_file.length()-4)+"%04d"+record_file.right(4);
+                png_output = true;
+            } else {
+                framename = "tmp-frame%04d.png";
+                png_output = false;
+            }
+            foreach (QImage* img, frames) {
+                progress.setValue(progress.value()+1);
+                if (progress.wasCanceled())
+                    break;
+                QString name;
+                name.sprintf(framename.toLocal8Bit(),frame++);
+                if (record_outsize.isValid())
+                    *img = img->scaled(record_outsize,Qt::IgnoreAspectRatio,Qt::SmoothTransformation);
+                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->save(name);
+                inputs << name;
+                delete img;
+            }
+
+            if (!progress.wasCanceled()) {
+                if (png_output) {
+                    framename.replace(QRegExp("%\\d*."),"*");
+                    qDebug() << "Wrote frames" << framename;
+                    inputs.clear(); // don't remove them
+                } else {
+                    // ImageMagick and gifsicle for GIF encoding
+                    progress.setLabelText(tr("Converting frames to GIF file..."));
+                    QStringList args;
+                    args << "-delay" << QString::number(period/10);
+                    args << inputs;
+                    args << record_file;
+                    qDebug() << "Converting..." << record_file << "(this may take a while)";
+                    if (0!=QProcess::execute("convert", args)) {
+                        qWarning() << "Cannot run ImageMagick 'convert' - recorded frames not converted";
+                        inputs.clear(); // don't remove them
+                        qDebug() << "Wrote frames tmp-frame*.png";
+                    } else {
+                        if (record_file.right(4).toLower() == ".gif") {
+                            qDebug() << "Compressing..." << record_file;
+                            if (0!=QProcess::execute("gifsicle", QStringList() << "-O2" << "-o" << record_file << record_file))
+                                qWarning() << "Cannot run 'gifsicle' - not compressed";
+                        }
+                        qDebug() << "Wrote" << record_file;
+                    }
+                }
+            }
+
+            progress.setValue(progress.maximum()-1);
+            foreach (QString name, inputs)
+                QFile::remove(name);
+
+            frames.clear();
+        }
+    }
+    qDebug() << "Recording: " << (recordTimer.isRunning()?"ON":"OFF");
+}
+
+void QmlViewer::ffmpegFinished(int code)
+{
+    qDebug() << "ffmpeg returned" << code << frame_stream->readAllStandardError();
+}
+
+void QmlViewer::autoStartRecording()
+{
+    setRecording(true);
+    autoStopTimer.setInterval(record_autotime);
+    autoStopTimer.setRunning(true);
+}
+
+void QmlViewer::autoStopRecording()
+{
+    setRecording(false);
+}
+
+void QmlViewer::recordFrame()
+{
+    canvas->QWidget::render(&frame);
+    if (frame_stream) {
+        if (frame_fmt == ".gif") {
+            // ffmpeg can't do 32bpp with gif
+            QImage rgb24 = frame.convertToFormat(QImage::Format_RGB888);
+            frame_stream->write((char*)rgb24.bits(),rgb24.numBytes());
+        } else {
+            frame_stream->write((char*)frame.bits(),frame.numBytes());
+        }
+    } else {
+        frames.append(new QImage(frame));
+    }
+}
+
+void QmlViewer::setDeviceKeys(bool on)
+{
+    devicemode = on;
+}
+
+void QmlViewer::setNetworkCacheSize(int size)
+{
+    namFactory->setCacheSize(size);
+}
+
+void QmlViewer::setUseGL(bool useGL)
+{
+#ifdef GL_SUPPORTED
+    if (useGL) {
+        QGLFormat format = QGLFormat::defaultFormat();
+        format.setSampleBuffers(false);
+
+        QGLWidget *glWidget = new QGLWidget(format);
+        glWidget->setAutoFillBackground(false);
+        canvas->setViewport(glWidget);
+    }
+#endif
+}
+
+void QmlViewer::setUseNativeFileBrowser(bool use)
+{
+    useQmlFileBrowser = !use;
+}
+
+QT_END_NAMESPACE
+
+#include "qmlviewer.moc"
diff --git a/tools/qmlviewer/qmlviewer.h b/tools/qmlviewer/qmlviewer.h
new file mode 100644
index 0000000..6b05584
--- /dev/null
+++ b/tools/qmlviewer/qmlviewer.h
@@ -0,0 +1,194 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QMLVIEWER_H
+#define QMLVIEWER_H
+
+#include <QMainWindow>
+#include <QMenuBar>
+#include <private/qmltimer_p.h>
+#include <QTime>
+#include <QList>
+
+QT_BEGIN_NAMESPACE
+
+class QmlView;
+class PreviewDeviceSkin;
+class QmlGraphicsTestEngine;
+class QProcess;
+class RecordingDialog;
+class QmlGraphicsTester;
+class QNetworkReply;
+class QNetworkCookieJar;
+class NetworkAccessManagerFactory;
+
+class QmlViewer
+#if defined(Q_OS_SYMBIAN)
+    : public QMainWindow
+#else
+    : public QWidget
+#endif
+{
+Q_OBJECT
+public:
+    QmlViewer(QWidget *parent=0, Qt::WindowFlags flags=0);
+    ~QmlViewer();
+
+    enum ScriptOption {
+        Play = 0x00000001,
+        Record = 0x00000002,
+        TestImages = 0x00000004,
+        TestErrorProperty = 0x00000008,
+        SaveOnExit = 0x00000010,
+        ExitOnComplete = 0x00000020,
+        ExitOnFailure = 0x00000040
+    };
+    Q_DECLARE_FLAGS(ScriptOptions, ScriptOption)
+    void setScript(const QString &s) { m_script = s; }
+    void setScriptOptions(ScriptOptions opt) { m_scriptOptions = opt; }
+    void setRecordDither(const QString& s) { record_dither = s; }
+    void setRecordRate(int fps);
+    void setRecordFile(const QString&);
+    void setRecordArgs(const QStringList&);
+    void setRecording(bool on);
+    bool isRecording() const { return recordTimer.isRunning(); }
+    void setAutoRecord(int from, int to);
+    void setDeviceKeys(bool);
+    void setNetworkCacheSize(int size);
+    void addLibraryPath(const QString& lib);
+    void setUseGL(bool use);
+    void setUseNativeFileBrowser(bool);
+
+    QStringList builtinSkins() const;
+
+    QMenuBar *menuBar() const;
+
+public slots:
+    void sceneResized(QSize size);
+    void open(const QString&);
+    void openWgt(const QString&);
+    void openQml(const QString&);
+    void openFile();
+    void reload();
+    void takeSnapShot();
+    void toggleRecording();
+    void toggleRecordingWithSelection();
+    void ffmpegFinished(int code);
+    void setSkin(const QString& skinDirectory);
+    void showProxySettings ();
+    void proxySettingsChanged ();
+    void setScaleView();
+    void executeErrors();
+    void setSlowMode(bool);
+    void launch(const QString &);
+
+protected:
+    virtual void keyPressEvent(QKeyEvent *);
+
+    void createMenu(QMenuBar *menu, QMenu *flatmenu);
+
+private slots:
+    void autoStartRecording();
+    void autoStopRecording();
+    void recordFrame();
+    void chooseRecordingOptions();
+    void pickRecordingFile();
+    void setScaleSkin();
+    void adjustSizeSlot();
+    void setPortrait();
+    void setLandscape();
+    void toggleOrientation();
+    void startNetwork();
+    void toggleFullScreen();
+    void unpackWgt();
+
+private:
+    QString getVideoFileName();
+
+    PreviewDeviceSkin *skin;
+    QSize skinscreensize;
+    QmlView *canvas;
+    QString currentFileOrUrl;
+    QmlTimer recordTimer;
+    QString frame_fmt;
+    QImage frame;
+    QList<QImage*> frames;
+    QProcess* frame_stream;
+    QmlTimer autoStartTimer;
+    QmlTimer autoStopTimer;
+    QString record_dither;
+    QString record_file;
+    QSize record_outsize;
+    QStringList record_args;
+    int record_rate;
+    int record_autotime;
+    bool devicemode;
+    QAction *recordAction;
+    QString currentSkin;
+    bool scaleSkin;
+    mutable QMenuBar *mb;
+    RecordingDialog *recdlg;
+
+    void senseImageMagick();
+    void senseFfmpeg();
+    QWidget *ffmpegHelpWindow;
+    bool ffmpegAvailable;
+    bool convertAvailable;
+
+    QAction *portraitOrientation;
+    QAction *landscapeOrientation;
+
+    QString m_script;
+    ScriptOptions m_scriptOptions;
+    QmlGraphicsTester *tester;
+
+    QNetworkReply *wgtreply;
+    QString wgtdir;
+
+    NetworkAccessManagerFactory *namFactory;
+
+    bool useQmlFileBrowser;
+};
+Q_DECLARE_OPERATORS_FOR_FLAGS(QmlViewer::ScriptOptions)
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/tools/qmlviewer/qmlviewer.pro b/tools/qmlviewer/qmlviewer.pro
new file mode 100644
index 0000000..35e4ba8
--- /dev/null
+++ b/tools/qmlviewer/qmlviewer.pro
@@ -0,0 +1,54 @@
+TEMPLATE = app
+CONFIG += qt \
+    uic
+DESTDIR = ../../bin
+QT += declarative \
+    script \
+    network \
+    sql
+
+contains(QT_CONFIG, opengl) {
+    QT += opengl
+    DEFINES += GL_SUPPORTED
+}
+
+# Input
+HEADERS += qmlviewer.h \
+           proxysettings.h \
+           qfxtester.h \
+           deviceorientation.h \
+           qmlfolderlistmodel.h
+SOURCES += main.cpp \
+           qmlviewer.cpp \
+           proxysettings.cpp \
+           qfxtester.cpp \
+           qmlfolderlistmodel.cpp
+RESOURCES = qmlviewer.qrc
+maemo5 {
+    SOURCES += deviceorientation_maemo.cpp
+} else {
+    SOURCES += deviceorientation.cpp
+}
+FORMS = recopts.ui \
+    proxysettings.ui
+INCLUDEPATH += ../../include/QtDeclarative
+INCLUDEPATH += ../../src/declarative/util
+include(../shared/deviceskin/deviceskin.pri)
+target.path = $$[QT_INSTALL_BINS]
+INSTALLS += target
+
+wince* {
+QT += scripttools \
+    xml \
+    xmlpatterns \
+    webkit \
+    phonon
+}
+symbian {
+#    TARGET.UID3 =
+    include($$QT_SOURCE_TREE/examples/symbianpkgrules.pri)
+    TARGET.EPOCHEAPSIZE = 0x20000 0x2000000
+    HEADERS += $$QT_SOURCE_TREE/examples/network/qftp/sym_iap_util.h
+    LIBS += -lesock  -lconnmon -linsock
+    TARGET.CAPABILITY = NetworkServices
+}
diff --git a/tools/qmlviewer/qmlviewer.qrc b/tools/qmlviewer/qmlviewer.qrc
new file mode 100644
index 0000000..3a9e608
--- /dev/null
+++ b/tools/qmlviewer/qmlviewer.qrc
@@ -0,0 +1,9 @@
+<RCC>
+    <qresource prefix="/" >
+        <file>content/Browser.qml</file>
+        <file>content/images/up.png</file>
+        <file>content/images/folder.png</file>
+        <file>content/images/titlebar.sci</file>
+        <file>content/images/titlebar.png</file>
+    </qresource>
+</RCC>
diff --git a/tools/qmlviewer/recopts.ui b/tools/qmlviewer/recopts.ui
new file mode 100644
index 0000000..ce2da30
--- /dev/null
+++ b/tools/qmlviewer/recopts.ui
@@ -0,0 +1,513 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>RecordingOptions</class>
+ <widget class="QDialog" name="RecordingOptions">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>316</width>
+    <height>436</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Video options</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_3">
+     <item>
+      <widget class="QLabel" name="label">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>File:</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLineEdit" name="file"/>
+     </item>
+     <item>
+      <widget class="QToolButton" name="pickfile">
+       <property name="text">
+        <string>...</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="groupBox">
+     <property name="title">
+      <string>Size</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_2">
+      <item row="0" column="0">
+       <widget class="QRadioButton" name="sizeOriginal">
+        <property name="text">
+         <string/>
+        </property>
+        <property name="checked">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="QRadioButton" name="sizeVGA">
+        <property name="text">
+         <string>VGA</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QRadioButton" name="size720p">
+        <property name="text">
+         <string>720p</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="QRadioButton" name="sizeQVGA">
+        <property name="text">
+         <string>QVGA</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0" colspan="3">
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
+        <item>
+         <widget class="QRadioButton" name="sizeCustom">
+          <property name="text">
+           <string>Width:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QSpinBox" name="sizeWidth">
+          <property name="minimum">
+           <number>1</number>
+          </property>
+          <property name="maximum">
+           <number>9999</number>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLabel" name="label_2">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Height:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QSpinBox" name="sizeHeight">
+          <property name="minimum">
+           <number>1</number>
+          </property>
+          <property name="maximum">
+           <number>9999</number>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <spacer name="horizontalSpacer_3">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeType">
+           <enum>QSizePolicy::MinimumExpanding</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+       </layout>
+      </item>
+      <item row="0" column="2">
+       <spacer name="horizontalSpacer_4">
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeType">
+         <enum>QSizePolicy::MinimumExpanding</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>40</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="rateOptions">
+     <property name="title">
+      <string>Rate</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_4">
+      <item row="0" column="0">
+       <widget class="QRadioButton" name="hz60">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="text">
+         <string>60Hz</string>
+        </property>
+        <property name="checked">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QRadioButton" name="hz50">
+        <property name="text">
+         <string>50Hz</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="2">
+       <widget class="QRadioButton" name="hz25">
+        <property name="text">
+         <string>25Hz</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0" colspan="4">
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <property name="spacing">
+         <number>0</number>
+        </property>
+        <item>
+         <widget class="QRadioButton" name="hzCustom">
+          <property name="text">
+           <string/>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLineEdit" name="hz">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="minimumSize">
+           <size>
+            <width>60</width>
+            <height>0</height>
+           </size>
+          </property>
+          <property name="maximumSize">
+           <size>
+            <width>100</width>
+            <height>16777215</height>
+           </size>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLabel" name="label_3">
+          <property name="text">
+           <string>Hz</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <spacer name="horizontalSpacer_2">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeType">
+           <enum>QSizePolicy::MinimumExpanding</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+       </layout>
+      </item>
+      <item row="1" column="2">
+       <widget class="QRadioButton" name="hz24">
+        <property name="text">
+         <string>24Hz</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="3">
+       <spacer name="horizontalSpacer">
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeType">
+         <enum>QSizePolicy::MinimumExpanding</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>40</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item row="0" column="1">
+       <spacer name="horizontalSpacer_5">
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeType">
+         <enum>QSizePolicy::Fixed</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="ffmpegOptions">
+     <property name="title">
+      <string>Profile</string>
+     </property>
+     <layout class="QGridLayout" name="gridLayout_3">
+      <item row="0" column="0" colspan="3">
+       <widget class="QComboBox" name="profile"/>
+      </item>
+      <item row="1" column="0" colspan="2">
+       <widget class="QLineEdit" name="args"/>
+      </item>
+      <item row="1" column="2">
+       <widget class="QToolButton" name="ffmpegHelp">
+        <property name="text">
+         <string>Help</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QLabel" name="warning">
+     <property name="text">
+      <string/>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <tabstops>
+  <tabstop>file</tabstop>
+  <tabstop>pickfile</tabstop>
+  <tabstop>sizeOriginal</tabstop>
+  <tabstop>sizeVGA</tabstop>
+  <tabstop>size720p</tabstop>
+  <tabstop>sizeQVGA</tabstop>
+  <tabstop>sizeCustom</tabstop>
+  <tabstop>sizeWidth</tabstop>
+  <tabstop>sizeHeight</tabstop>
+  <tabstop>hz60</tabstop>
+  <tabstop>hz25</tabstop>
+  <tabstop>hz50</tabstop>
+  <tabstop>hz24</tabstop>
+  <tabstop>hzCustom</tabstop>
+  <tabstop>hz</tabstop>
+  <tabstop>profile</tabstop>
+  <tabstop>args</tabstop>
+  <tabstop>ffmpegHelp</tabstop>
+  <tabstop>buttonBox</tabstop>
+ </tabstops>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>hzCustom</sender>
+   <signal>clicked()</signal>
+   <receiver>hz</receiver>
+   <slot>setFocus()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>43</x>
+     <y>257</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>129</x>
+     <y>262</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>hz</sender>
+   <signal>textChanged(QString)</signal>
+   <receiver>hzCustom</receiver>
+   <slot>toggle()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>143</x>
+     <y>262</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>43</x>
+     <y>257</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>hz</sender>
+   <signal>selectionChanged()</signal>
+   <receiver>hzCustom</receiver>
+   <slot>toggle()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>143</x>
+     <y>262</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>43</x>
+     <y>257</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>RecordingOptions</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>258</x>
+     <y>424</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>60</x>
+     <y>219</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>RecordingOptions</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>258</x>
+     <y>424</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>92</x>
+     <y>219</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>profile</sender>
+   <signal>activated(int)</signal>
+   <receiver>RecordingOptions</receiver>
+   <slot>pickProfile(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>92</x>
+     <y>329</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>48</x>
+     <y>194</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>args</sender>
+   <signal>textEdited(QString)</signal>
+   <receiver>RecordingOptions</receiver>
+   <slot>storeCustomArgs(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>128</x>
+     <y>357</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>102</x>
+     <y>189</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>sizeWidth</sender>
+   <signal>valueChanged(int)</signal>
+   <receiver>sizeCustom</receiver>
+   <slot>toggle()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>108</x>
+     <y>133</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>48</x>
+     <y>133</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>sizeHeight</sender>
+   <signal>valueChanged(int)</signal>
+   <receiver>sizeCustom</receiver>
+   <slot>toggle()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>212</x>
+     <y>133</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>64</x>
+     <y>129</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+ <slots>
+  <signal>filePicked(QString)</signal>
+  <signal>argumentsPicked(QString)</signal>
+  <slot>pickFile()</slot>
+  <slot>pickProfile(int)</slot>
+  <slot>storeCustomArgs(QString)</slot>
+ </slots>
+</ui>