Merge branch 'master' of scm.dev.nokia.troll.no:qt/qt-qml into master-integration

* 'master' of scm.dev.nokia.troll.no:qt/qt-qml: (3377 commits)
  Expect fail.
  Expect fails.
  Attempt to clairify highlight range docs
  Make sure item release isn't deferred indefinately
  Expect fail.
  Missing file
  Exclude plugins example in test.
  Test
  Crash
  Fix tests
  Compile.
  Remove pathview test.
  Remove unneeded
  Fix repeater test.
  Revert "Remove unimplemented methods from header"
  Revert "Replace QList<>* support with QmlListProperty"
  Revert "Compile"
  Add expected fail and created QTBUG-8072 for qml animation auto-test
  Fix expected error message.
  Consolidate the two pathview tests and fix them all.
  ...

51 files changed, 7929 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..1566473
--- /dev/null
+++ b/tools/qmlviewer/qmlviewer.cpp
@@ -0,0 +1,1455 @@
+/****************************************************************************
+**
+** 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) {}
+    ~NetworkAccessManagerFactory() {
+        delete cookieJar;
+    }
+
+    QNetworkAccessManager *create(QObject *parent) {
+        QMutexLocker lock(&mutex);
+        QNetworkAccessManager *manager = new QNetworkAccessManager(parent);
+        if (!cookieJar)
+            cookieJar = new PersistentCookieJar(0);
+        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 network access 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>