Added a gesture-enabled browser demo.

56 files changed, 12906 insertions, 0 deletions

diff --git a/examples/gestures/browser/Info_mac.plist b/examples/gestures/browser/Info_mac.plist
new file mode 100644
index 0000000..5648631
--- /dev/null
+++ b/examples/gestures/browser/Info_mac.plist
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist SYSTEM "file://localhost/System/Library/DTDs/PropertyList.dtd">
+<plist version="0.9">
+<dict>
+	<key>CFBundleIconFile</key>
+	<string>@ICON@</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+        <key>CFBundleGetInfoString</key>
+	<string>Created by Qt/QMake</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.trolltech.DemoBrowser</string>
+	<key>CFBundleSignature</key>
+	<string>ttxt</string>
+	<key>CFBundleExecutable</key>
+	<string>@EXECUTABLE@</string>
+	<key>CFBundleDocumentTypes</key>
+        <array>
+                <dict>
+                        <key>CFBundleTypeExtensions</key>
+                        <array>
+                                <string>html</string>
+                                <string>htm</string>
+                                <string>shtml</string>
+                                <string>xht</string>
+                                <string>xhtml</string>
+                        </array>
+			<key>CFBundleTypeIconFile</key>
+			<string>@ICON@</string>
+                        <key>CFBundleTypeName</key>
+                        <string>HTML Document</string>
+                        <key>CFBundleTypeOSTypes</key>
+                        <array>
+                                <string>HTML</string>
+                        </array>
+                        <key>CFBundleTypeRole</key>
+                        <string>Viewer</string>
+                </dict>
+        </array>
+	<key>NOTE</key>
+	<string>DemoBrowser by Nokia Corporation and/or its subsidiary(-ies)</string>
+</dict>
+</plist>
diff --git a/examples/gestures/browser/addbookmarkdialog.ui b/examples/gestures/browser/addbookmarkdialog.ui
new file mode 100644
index 0000000..3460d7b
--- /dev/null
+++ b/examples/gestures/browser/addbookmarkdialog.ui
@@ -0,0 +1,98 @@
+<ui version="4.0" >
+ <class>AddBookmarkDialog</class>
+ <widget class="QDialog" name="AddBookmarkDialog" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>240</width>
+    <height>168</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Add Bookmark</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout" >
+   <item>
+    <widget class="QLabel" name="label" >
+     <property name="text" >
+      <string>Type a name for the bookmark, and choose where to keep it.</string>
+     </property>
+     <property name="textFormat" >
+      <enum>Qt::PlainText</enum>
+     </property>
+     <property name="wordWrap" >
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QLineEdit" name="name" />
+   </item>
+   <item>
+    <widget class="QComboBox" name="location" />
+   </item>
+   <item>
+    <spacer name="verticalSpacer" >
+     <property name="orientation" >
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0" >
+      <size>
+       <width>20</width>
+       <height>2</height>
+      </size>
+     </property>
+    </spacer>
+   </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>
+     <property name="centerButtons" >
+      <bool>false</bool>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>AddBookmarkDialog</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>AddBookmarkDialog</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/examples/gestures/browser/autosaver.cpp b/examples/gestures/browser/autosaver.cpp
new file mode 100644
index 0000000..ea8c182
--- /dev/null
+++ b/examples/gestures/browser/autosaver.cpp
@@ -0,0 +1,94 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "autosaver.h"
+
+#include <QtCore/QDir>
+#include <QtCore/QCoreApplication>
+#include <QtCore/QMetaObject>
+#include <QtDebug>
+
+#define AUTOSAVE_IN  1000 * 3  // seconds
+#define MAXWAIT      1000 * 15 // seconds
+
+AutoSaver::AutoSaver(QObject *parent) : QObject(parent)
+{
+    Q_ASSERT(parent);
+}
+
+AutoSaver::~AutoSaver()
+{
+    if (m_timer.isActive())
+        qWarning() << "AutoSaver: still active when destroyed, changes not saved.";
+}
+
+void AutoSaver::changeOccurred()
+{
+    if (m_firstChange.isNull())
+        m_firstChange.start();
+
+    if (m_firstChange.elapsed() > MAXWAIT) {
+        saveIfNeccessary();
+    } else {
+        m_timer.start(AUTOSAVE_IN, this);
+    }
+}
+
+void AutoSaver::timerEvent(QTimerEvent *event)
+{
+    if (event->timerId() == m_timer.timerId()) {
+        saveIfNeccessary();
+    } else {
+        QObject::timerEvent(event);
+    }
+}
+
+void AutoSaver::saveIfNeccessary()
+{
+    if (!m_timer.isActive())
+        return;
+    m_timer.stop();
+    m_firstChange = QTime();
+    if (!QMetaObject::invokeMethod(parent(), "save", Qt::DirectConnection)) {
+        qWarning() << "AutoSaver: error invoking slot save() on parent";
+    }
+}
+
diff --git a/examples/gestures/browser/autosaver.h b/examples/gestures/browser/autosaver.h
new file mode 100644
index 0000000..e6f2b79
--- /dev/null
+++ b/examples/gestures/browser/autosaver.h
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef AUTOSAVER_H
+#define AUTOSAVER_H
+
+#include <QtCore/QObject>
+#include <QtCore/QBasicTimer>
+#include <QtCore/QTime>
+
+/*
+    This class will call the save() slot on the parent object when the parent changes.
+    It will wait several seconds after changed() to combining multiple changes and
+    prevent continuous writing to disk.
+  */
+class AutoSaver : public QObject {
+
+Q_OBJECT
+
+public:
+    AutoSaver(QObject *parent);
+    ~AutoSaver();
+    void saveIfNeccessary();
+
+public slots:
+    void changeOccurred();
+
+protected:
+    void timerEvent(QTimerEvent *event);
+
+private:
+    QBasicTimer m_timer;
+    QTime m_firstChange;
+
+};
+
+#endif // AUTOSAVER_H
+
diff --git a/examples/gestures/browser/bookmarks.cpp b/examples/gestures/browser/bookmarks.cpp
new file mode 100644
index 0000000..56a4d89
--- /dev/null
+++ b/examples/gestures/browser/bookmarks.cpp
@@ -0,0 +1,987 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "bookmarks.h"
+
+#include "autosaver.h"
+#include "browserapplication.h"
+#include "history.h"
+#include "xbel.h"
+
+#include <QtCore/QBuffer>
+#include <QtCore/QFile>
+#include <QtCore/QMimeData>
+
+#include <QtGui/QDesktopServices>
+#include <QtGui/QDragEnterEvent>
+#include <QtGui/QFileDialog>
+#include <QtGui/QHeaderView>
+#include <QtGui/QIcon>
+#include <QtGui/QMessageBox>
+#include <QtGui/QToolButton>
+
+#include <QtWebKit/QWebSettings>
+
+#include <QtCore/QDebug>
+
+#define BOOKMARKBAR "Bookmarks Bar"
+#define BOOKMARKMENU "Bookmarks Menu"
+
+BookmarksManager::BookmarksManager(QObject *parent)
+    : QObject(parent)
+    , m_loaded(false)
+    , m_saveTimer(new AutoSaver(this))
+    , m_bookmarkRootNode(0)
+    , m_bookmarkModel(0)
+{
+    connect(this, SIGNAL(entryAdded(BookmarkNode *)),
+            m_saveTimer, SLOT(changeOccurred()));
+    connect(this, SIGNAL(entryRemoved(BookmarkNode *, int, BookmarkNode *)),
+            m_saveTimer, SLOT(changeOccurred()));
+    connect(this, SIGNAL(entryChanged(BookmarkNode *)),
+            m_saveTimer, SLOT(changeOccurred()));
+}
+
+BookmarksManager::~BookmarksManager()
+{
+    m_saveTimer->saveIfNeccessary();
+}
+
+void BookmarksManager::changeExpanded()
+{
+    m_saveTimer->changeOccurred();
+}
+
+void BookmarksManager::load()
+{
+    if (m_loaded)
+        return;
+    m_loaded = true;
+
+    QString dir = QDesktopServices::storageLocation(QDesktopServices::DataLocation);
+    QString bookmarkFile = dir + QLatin1String("/bookmarks.xbel");
+    if (!QFile::exists(bookmarkFile))
+        bookmarkFile = QLatin1String(":defaultbookmarks.xbel");
+
+    XbelReader reader;
+    m_bookmarkRootNode = reader.read(bookmarkFile);
+    if (reader.error() != QXmlStreamReader::NoError) {
+        QMessageBox::warning(0, QLatin1String("Loading Bookmark"),
+            tr("Error when loading bookmarks on line %1, column %2:\n"
+               "%3").arg(reader.lineNumber()).arg(reader.columnNumber()).arg(reader.errorString()));
+    }
+
+    BookmarkNode *toolbar = 0;
+    BookmarkNode *menu = 0;
+    QList<BookmarkNode*> others;
+    for (int i = m_bookmarkRootNode->children().count() - 1; i >= 0; --i) {
+        BookmarkNode *node = m_bookmarkRootNode->children().at(i);
+        if (node->type() == BookmarkNode::Folder) {
+            // Automatically convert
+            if (node->title == tr("Toolbar Bookmarks") && !toolbar) {
+                node->title = tr(BOOKMARKBAR);
+            }
+            if (node->title == tr(BOOKMARKBAR) && !toolbar) {
+                toolbar = node;
+            }
+
+            // Automatically convert
+            if (node->title == tr("Menu") && !menu) {
+                node->title = tr(BOOKMARKMENU);
+            }
+            if (node->title == tr(BOOKMARKMENU) && !menu) {
+                menu = node;
+            }
+        } else {
+            others.append(node);
+        }
+        m_bookmarkRootNode->remove(node);
+    }
+    Q_ASSERT(m_bookmarkRootNode->children().count() == 0);
+    if (!toolbar) {
+        toolbar = new BookmarkNode(BookmarkNode::Folder, m_bookmarkRootNode);
+        toolbar->title = tr(BOOKMARKBAR);
+    } else {
+        m_bookmarkRootNode->add(toolbar);
+    }
+
+    if (!menu) {
+        menu = new BookmarkNode(BookmarkNode::Folder, m_bookmarkRootNode);
+        menu->title = tr(BOOKMARKMENU);
+    } else {
+        m_bookmarkRootNode->add(menu);
+    }
+
+    for (int i = 0; i < others.count(); ++i)
+        menu->add(others.at(i));
+}
+
+void BookmarksManager::save() const
+{
+    if (!m_loaded)
+        return;
+
+    XbelWriter writer;
+    QString dir = QDesktopServices::storageLocation(QDesktopServices::DataLocation);
+    QString bookmarkFile = dir + QLatin1String("/bookmarks.xbel");
+    if (!writer.write(bookmarkFile, m_bookmarkRootNode))
+        qWarning() << "BookmarkManager: error saving to" << bookmarkFile;
+}
+
+void BookmarksManager::addBookmark(BookmarkNode *parent, BookmarkNode *node, int row)
+{
+    if (!m_loaded)
+        return;
+    Q_ASSERT(parent);
+    InsertBookmarksCommand *command = new InsertBookmarksCommand(this, parent, node, row);
+    m_commands.push(command);
+}
+
+void BookmarksManager::removeBookmark(BookmarkNode *node)
+{
+    if (!m_loaded)
+        return;
+
+    Q_ASSERT(node);
+    BookmarkNode *parent = node->parent();
+    int row = parent->children().indexOf(node);
+    RemoveBookmarksCommand *command = new RemoveBookmarksCommand(this, parent, row);
+    m_commands.push(command);
+}
+
+void BookmarksManager::setTitle(BookmarkNode *node, const QString &newTitle)
+{
+    if (!m_loaded)
+        return;
+
+    Q_ASSERT(node);
+    ChangeBookmarkCommand *command = new ChangeBookmarkCommand(this, node, newTitle, true);
+    m_commands.push(command);
+}
+
+void BookmarksManager::setUrl(BookmarkNode *node, const QString &newUrl)
+{
+    if (!m_loaded)
+        return;
+
+    Q_ASSERT(node);
+    ChangeBookmarkCommand *command = new ChangeBookmarkCommand(this, node, newUrl, false);
+    m_commands.push(command);
+}
+
+BookmarkNode *BookmarksManager::bookmarks()
+{
+    if (!m_loaded)
+        load();
+    return m_bookmarkRootNode;
+}
+
+BookmarkNode *BookmarksManager::menu()
+{
+    if (!m_loaded)
+        load();
+
+    for (int i = m_bookmarkRootNode->children().count() - 1; i >= 0; --i) {
+        BookmarkNode *node = m_bookmarkRootNode->children().at(i);
+        if (node->title == tr(BOOKMARKMENU))
+            return node;
+    }
+    Q_ASSERT(false);
+    return 0;
+}
+
+BookmarkNode *BookmarksManager::toolbar()
+{
+    if (!m_loaded)
+        load();
+
+    for (int i = m_bookmarkRootNode->children().count() - 1; i >= 0; --i) {
+        BookmarkNode *node = m_bookmarkRootNode->children().at(i);
+        if (node->title == tr(BOOKMARKBAR))
+            return node;
+    }
+    Q_ASSERT(false);
+    return 0;
+}
+
+BookmarksModel *BookmarksManager::bookmarksModel()
+{
+    if (!m_bookmarkModel)
+        m_bookmarkModel = new BookmarksModel(this, this);
+    return m_bookmarkModel;
+}
+
+void BookmarksManager::importBookmarks()
+{
+    QString fileName = QFileDialog::getOpenFileName(0, tr("Open File"),
+                                                     QString(),
+                                                     tr("XBEL (*.xbel *.xml)"));
+    if (fileName.isEmpty())
+        return;
+
+    XbelReader reader;
+    BookmarkNode *importRootNode = reader.read(fileName);
+    if (reader.error() != QXmlStreamReader::NoError) {
+        QMessageBox::warning(0, QLatin1String("Loading Bookmark"),
+            tr("Error when loading bookmarks on line %1, column %2:\n"
+               "%3").arg(reader.lineNumber()).arg(reader.columnNumber()).arg(reader.errorString()));
+    }
+
+    importRootNode->setType(BookmarkNode::Folder);
+    importRootNode->title = (tr("Imported %1").arg(QDate::currentDate().toString(Qt::SystemLocaleShortDate)));
+    addBookmark(menu(), importRootNode);
+}
+
+void BookmarksManager::exportBookmarks()
+{
+    QString fileName = QFileDialog::getSaveFileName(0, tr("Save File"),
+                                tr("%1 Bookmarks.xbel").arg(QCoreApplication::applicationName()),
+                                tr("XBEL (*.xbel *.xml)"));
+    if (fileName.isEmpty())
+        return;
+
+    XbelWriter writer;
+    if (!writer.write(fileName, m_bookmarkRootNode))
+        QMessageBox::critical(0, tr("Export error"), tr("error saving bookmarks"));
+}
+
+RemoveBookmarksCommand::RemoveBookmarksCommand(BookmarksManager *m_bookmarkManagaer, BookmarkNode *parent, int row)
+    : QUndoCommand(BookmarksManager::tr("Remove Bookmark"))
+    , m_row(row)
+    , m_bookmarkManagaer(m_bookmarkManagaer)
+    , m_node(parent->children().value(row))
+    , m_parent(parent)
+    , m_done(false)
+{
+}
+
+RemoveBookmarksCommand::~RemoveBookmarksCommand()
+{
+    if (m_done && !m_node->parent()) {
+        delete m_node;
+    }
+}
+
+void RemoveBookmarksCommand::undo()
+{
+    m_parent->add(m_node, m_row);
+    emit m_bookmarkManagaer->entryAdded(m_node);
+    m_done = false;
+}
+
+void RemoveBookmarksCommand::redo()
+{
+    m_parent->remove(m_node);
+    emit m_bookmarkManagaer->entryRemoved(m_parent, m_row, m_node);
+    m_done = true;
+}
+
+InsertBookmarksCommand::InsertBookmarksCommand(BookmarksManager *m_bookmarkManagaer,
+                BookmarkNode *parent, BookmarkNode *node, int row)
+    : RemoveBookmarksCommand(m_bookmarkManagaer, parent, row)
+{
+    setText(BookmarksManager::tr("Insert Bookmark"));
+    m_node = node;
+}
+
+ChangeBookmarkCommand::ChangeBookmarkCommand(BookmarksManager *m_bookmarkManagaer, BookmarkNode *node,
+                        const QString &newValue, bool title)
+    : QUndoCommand()
+    , m_bookmarkManagaer(m_bookmarkManagaer)
+    , m_title(title)
+    , m_newValue(newValue)
+    , m_node(node)
+{
+    if (m_title) {
+        m_oldValue = m_node->title;
+        setText(BookmarksManager::tr("Name Change"));
+    } else {
+        m_oldValue = m_node->url;
+        setText(BookmarksManager::tr("Address Change"));
+    }
+}
+
+void ChangeBookmarkCommand::undo()
+{
+    if (m_title)
+        m_node->title = m_oldValue;
+    else
+        m_node->url = m_oldValue;
+    emit m_bookmarkManagaer->entryChanged(m_node);
+}
+
+void ChangeBookmarkCommand::redo()
+{
+    if (m_title)
+        m_node->title = m_newValue;
+    else
+        m_node->url = m_newValue;
+    emit m_bookmarkManagaer->entryChanged(m_node);
+}
+
+BookmarksModel::BookmarksModel(BookmarksManager *bookmarkManager, QObject *parent)
+    : QAbstractItemModel(parent)
+    , m_endMacro(false)
+    , m_bookmarksManager(bookmarkManager)
+{
+    connect(bookmarkManager, SIGNAL(entryAdded(BookmarkNode *)),
+            this, SLOT(entryAdded(BookmarkNode *)));
+    connect(bookmarkManager, SIGNAL(entryRemoved(BookmarkNode *, int, BookmarkNode *)),
+            this, SLOT(entryRemoved(BookmarkNode *, int, BookmarkNode *)));
+    connect(bookmarkManager, SIGNAL(entryChanged(BookmarkNode *)),
+            this, SLOT(entryChanged(BookmarkNode *)));
+}
+
+QModelIndex BookmarksModel::index(BookmarkNode *node) const
+{
+    BookmarkNode *parent = node->parent();
+    if (!parent)
+        return QModelIndex();
+    return createIndex(parent->children().indexOf(node), 0, node);
+}
+
+void BookmarksModel::entryAdded(BookmarkNode *item)
+{
+    Q_ASSERT(item && item->parent());
+    int row = item->parent()->children().indexOf(item);
+    BookmarkNode *parent = item->parent();
+    // item was already added so remove beore beginInsertRows is called
+    parent->remove(item);
+    beginInsertRows(index(parent), row, row);
+    parent->add(item, row);
+    endInsertRows();
+}
+
+void BookmarksModel::entryRemoved(BookmarkNode *parent, int row, BookmarkNode *item)
+{
+    // item was already removed, re-add so beginRemoveRows works
+    parent->add(item, row);
+    beginRemoveRows(index(parent), row, row);
+    parent->remove(item);
+    endRemoveRows();
+}
+
+void BookmarksModel::entryChanged(BookmarkNode *item)
+{
+    QModelIndex idx = index(item);
+    emit dataChanged(idx, idx);
+}
+
+bool BookmarksModel::removeRows(int row, int count, const QModelIndex &parent)
+{
+    if (row < 0 || count <= 0 || row + count > rowCount(parent))
+        return false;
+
+    BookmarkNode *bookmarkNode = node(parent);
+    for (int i = row + count - 1; i >= row; --i) {
+        BookmarkNode *node = bookmarkNode->children().at(i);
+        if (node == m_bookmarksManager->menu()
+            || node == m_bookmarksManager->toolbar())
+            continue;
+
+        m_bookmarksManager->removeBookmark(node);
+    }
+    if (m_endMacro) {
+        m_bookmarksManager->undoRedoStack()->endMacro();
+        m_endMacro = false;
+    }
+    return true;
+}
+
+QVariant BookmarksModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
+        switch (section) {
+            case 0: return tr("Title");
+            case 1: return tr("Address");
+        }
+    }
+    return QAbstractItemModel::headerData(section, orientation, role);
+}
+
+QVariant BookmarksModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || index.model() != this)
+        return QVariant();
+
+    const BookmarkNode *bookmarkNode = node(index);
+    switch (role) {
+    case Qt::EditRole:
+    case Qt::DisplayRole:
+        if (bookmarkNode->type() == BookmarkNode::Separator) {
+            switch (index.column()) {
+            case 0: return QString(50, 0xB7);
+            case 1: return QString();
+            }
+        }
+
+        switch (index.column()) {
+        case 0: return bookmarkNode->title;
+        case 1: return bookmarkNode->url;
+        }
+        break;
+    case BookmarksModel::UrlRole:
+        return QUrl(bookmarkNode->url);
+        break;
+    case BookmarksModel::UrlStringRole:
+        return bookmarkNode->url;
+        break;
+    case BookmarksModel::TypeRole:
+        return bookmarkNode->type();
+        break;
+    case BookmarksModel::SeparatorRole:
+        return (bookmarkNode->type() == BookmarkNode::Separator);
+        break;
+    case Qt::DecorationRole:
+        if (index.column() == 0) {
+            if (bookmarkNode->type() == BookmarkNode::Folder)
+                return QApplication::style()->standardIcon(QStyle::SP_DirIcon);
+            return BrowserApplication::instance()->icon(bookmarkNode->url);
+        }
+    }
+
+    return QVariant();
+}
+
+int BookmarksModel::columnCount(const QModelIndex &parent) const
+{
+    return (parent.column() > 0) ? 0 : 2;
+}
+
+int BookmarksModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.column() > 0)
+        return 0;
+
+    if (!parent.isValid())
+        return m_bookmarksManager->bookmarks()->children().count();
+
+    const BookmarkNode *item = static_cast<BookmarkNode*>(parent.internalPointer());
+    return item->children().count();
+}
+
+QModelIndex BookmarksModel::index(int row, int column, const QModelIndex &parent) const
+{
+    if (row < 0 || column < 0 || row >= rowCount(parent) || column >= columnCount(parent))
+        return QModelIndex();
+
+    // get the parent node
+    BookmarkNode *parentNode = node(parent);
+    return createIndex(row, column, parentNode->children().at(row));
+}
+
+QModelIndex BookmarksModel::parent(const QModelIndex &index) const
+{
+    if (!index.isValid())
+        return QModelIndex();
+
+    BookmarkNode *itemNode = node(index);
+    BookmarkNode *parentNode = (itemNode ? itemNode->parent() : 0);
+    if (!parentNode || parentNode == m_bookmarksManager->bookmarks())
+        return QModelIndex();
+
+    // get the parent's row
+    BookmarkNode *grandParentNode = parentNode->parent();
+    int parentRow = grandParentNode->children().indexOf(parentNode);
+    Q_ASSERT(parentRow >= 0);
+    return createIndex(parentRow, 0, parentNode);
+}
+
+bool BookmarksModel::hasChildren(const QModelIndex &parent) const
+{
+    if (!parent.isValid())
+        return true;
+    const BookmarkNode *parentNode = node(parent);
+    return (parentNode->type() == BookmarkNode::Folder);
+}
+
+Qt::ItemFlags BookmarksModel::flags(const QModelIndex &index) const
+{
+    if (!index.isValid())
+        return Qt::NoItemFlags;
+
+    Qt::ItemFlags flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
+
+    BookmarkNode *bookmarkNode = node(index);
+
+    if (bookmarkNode != m_bookmarksManager->menu()
+        && bookmarkNode != m_bookmarksManager->toolbar()) {
+        flags |= Qt::ItemIsDragEnabled;
+        if (bookmarkNode->type() != BookmarkNode::Separator)
+            flags |= Qt::ItemIsEditable;
+    }
+    if (hasChildren(index))
+        flags |= Qt::ItemIsDropEnabled;
+    return flags;
+}
+
+Qt::DropActions BookmarksModel::supportedDropActions () const
+{
+    return Qt::CopyAction | Qt::MoveAction;
+}
+
+#define MIMETYPE QLatin1String("application/bookmarks.xbel")
+
+QStringList BookmarksModel::mimeTypes() const
+{
+    QStringList types;
+    types << MIMETYPE;
+    return types;
+}
+
+QMimeData *BookmarksModel::mimeData(const QModelIndexList &indexes) const
+{
+    QMimeData *mimeData = new QMimeData();
+    QByteArray data;
+    QDataStream stream(&data, QIODevice::WriteOnly);
+    foreach (QModelIndex index, indexes) {
+        if (index.column() != 0 || !index.isValid())
+            continue;
+        QByteArray encodedData;
+        QBuffer buffer(&encodedData);
+        buffer.open(QBuffer::ReadWrite);
+        XbelWriter writer;
+        const BookmarkNode *parentNode = node(index);
+        writer.write(&buffer, parentNode);
+        stream << encodedData;
+    }
+    mimeData->setData(MIMETYPE, data);
+    return mimeData;
+}
+
+bool BookmarksModel::dropMimeData(const QMimeData *data,
+     Qt::DropAction action, int row, int column, const QModelIndex &parent)
+{
+    if (action == Qt::IgnoreAction)
+        return true;
+
+    if (!data->hasFormat(MIMETYPE)
+        || column > 0)
+        return false;
+
+    QByteArray ba = data->data(MIMETYPE);
+    QDataStream stream(&ba, QIODevice::ReadOnly);
+    if (stream.atEnd())
+        return false;
+
+    QUndoStack *undoStack = m_bookmarksManager->undoRedoStack();
+    undoStack->beginMacro(QLatin1String("Move Bookmarks"));
+
+    while (!stream.atEnd()) {
+        QByteArray encodedData;
+        stream >> encodedData;
+        QBuffer buffer(&encodedData);
+        buffer.open(QBuffer::ReadOnly);
+
+        XbelReader reader;
+        BookmarkNode *rootNode = reader.read(&buffer);
+        QList<BookmarkNode*> children = rootNode->children();
+        for (int i = 0; i < children.count(); ++i) {
+            BookmarkNode *bookmarkNode = children.at(i);
+            rootNode->remove(bookmarkNode);
+            row = qMax(0, row);
+            BookmarkNode *parentNode = node(parent);
+            m_bookmarksManager->addBookmark(parentNode, bookmarkNode, row);
+            m_endMacro = true;
+        }
+        delete rootNode;
+    }
+    return true;
+}
+
+bool BookmarksModel::setData(const QModelIndex &index, const QVariant &value, int role)
+{
+    if (!index.isValid() || (flags(index) & Qt::ItemIsEditable) == 0)
+        return false;
+
+    BookmarkNode *item = node(index);
+
+    switch (role) {
+    case Qt::EditRole:
+    case Qt::DisplayRole:
+        if (index.column() == 0) {
+            m_bookmarksManager->setTitle(item, value.toString());
+            break;
+        }
+        if (index.column() == 1) {
+            m_bookmarksManager->setUrl(item, value.toString());
+            break;
+        }
+        return false;
+    case BookmarksModel::UrlRole:
+        m_bookmarksManager->setUrl(item, value.toUrl().toString());
+        break;
+    case BookmarksModel::UrlStringRole:
+        m_bookmarksManager->setUrl(item, value.toString());
+        break;
+    default:
+        break;
+        return false;
+    }
+
+    return true;
+}
+
+BookmarkNode *BookmarksModel::node(const QModelIndex &index) const
+{
+    BookmarkNode *itemNode = static_cast<BookmarkNode*>(index.internalPointer());
+    if (!itemNode)
+        return m_bookmarksManager->bookmarks();
+    return itemNode;
+}
+
+
+AddBookmarkProxyModel::AddBookmarkProxyModel(QObject *parent)
+    : QSortFilterProxyModel(parent)
+{
+}
+
+int AddBookmarkProxyModel::columnCount(const QModelIndex &parent) const
+{
+    return qMin(1, QSortFilterProxyModel::columnCount(parent));
+}
+
+bool AddBookmarkProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
+{
+    QModelIndex idx = sourceModel()->index(source_row, 0, source_parent);
+    return sourceModel()->hasChildren(idx);
+}
+
+AddBookmarkDialog::AddBookmarkDialog(const QString &url, const QString &title, QWidget *parent, BookmarksManager *bookmarkManager)
+    : QDialog(parent)
+    , m_url(url)
+    , m_bookmarksManager(bookmarkManager)
+{
+    setWindowFlags(Qt::Sheet);
+    if (!m_bookmarksManager)
+        m_bookmarksManager = BrowserApplication::bookmarksManager();
+    setupUi(this);
+    QTreeView *view = new QTreeView(this);
+    m_proxyModel = new AddBookmarkProxyModel(this);
+    BookmarksModel *model = m_bookmarksManager->bookmarksModel();
+    m_proxyModel->setSourceModel(model);
+    view->setModel(m_proxyModel);
+    view->expandAll();
+    view->header()->setStretchLastSection(true);
+    view->header()->hide();
+    view->setItemsExpandable(false);
+    view->setRootIsDecorated(false);
+    view->setIndentation(10);
+    location->setModel(m_proxyModel);
+    view->show();
+    location->setView(view);
+    BookmarkNode *menu = m_bookmarksManager->menu();
+    QModelIndex idx = m_proxyModel->mapFromSource(model->index(menu));
+    view->setCurrentIndex(idx);
+    location->setCurrentIndex(idx.row());
+    name->setText(title);
+}
+
+void AddBookmarkDialog::accept()
+{
+    QModelIndex index = location->view()->currentIndex();
+    index = m_proxyModel->mapToSource(index);
+    if (!index.isValid())
+        index = m_bookmarksManager->bookmarksModel()->index(0, 0);
+    BookmarkNode *parent = m_bookmarksManager->bookmarksModel()->node(index);
+    BookmarkNode *bookmark = new BookmarkNode(BookmarkNode::Bookmark);
+    bookmark->url = m_url;
+    bookmark->title = name->text();
+    m_bookmarksManager->addBookmark(parent, bookmark);
+    QDialog::accept();
+}
+
+BookmarksMenu::BookmarksMenu(QWidget *parent)
+    : ModelMenu(parent)
+    , m_bookmarksManager(0)
+{
+    connect(this, SIGNAL(activated(const QModelIndex &)),
+            this, SLOT(activated(const QModelIndex &)));
+    setMaxRows(-1);
+    setHoverRole(BookmarksModel::UrlStringRole);
+    setSeparatorRole(BookmarksModel::SeparatorRole);
+}
+
+void BookmarksMenu::activated(const QModelIndex &index)
+{
+    emit openUrl(index.data(BookmarksModel::UrlRole).toUrl());
+}
+
+bool BookmarksMenu::prePopulated()
+{
+    m_bookmarksManager = BrowserApplication::bookmarksManager();
+    setModel(m_bookmarksManager->bookmarksModel());
+    setRootIndex(m_bookmarksManager->bookmarksModel()->index(1, 0));
+    // initial actions
+    for (int i = 0; i < m_initialActions.count(); ++i)
+        addAction(m_initialActions.at(i));
+    if (!m_initialActions.isEmpty())
+        addSeparator();
+    createMenu(model()->index(0, 0), 1, this);
+    return true;
+}
+
+void BookmarksMenu::setInitialActions(QList<QAction*> actions)
+{
+    m_initialActions = actions;
+    for (int i = 0; i < m_initialActions.count(); ++i)
+        addAction(m_initialActions.at(i));
+}
+
+BookmarksDialog::BookmarksDialog(QWidget *parent, BookmarksManager *manager)
+    : QDialog(parent)
+{
+    m_bookmarksManager = manager;
+    if (!m_bookmarksManager)
+        m_bookmarksManager = BrowserApplication::bookmarksManager();
+    setupUi(this);
+
+    tree->setUniformRowHeights(true);
+    tree->setSelectionBehavior(QAbstractItemView::SelectRows);
+    tree->setSelectionMode(QAbstractItemView::ContiguousSelection);
+    tree->setTextElideMode(Qt::ElideMiddle);
+    m_bookmarksModel = m_bookmarksManager->bookmarksModel();
+    m_proxyModel = new TreeProxyModel(this);
+    connect(search, SIGNAL(textChanged(QString)),
+            m_proxyModel, SLOT(setFilterFixedString(QString)));
+    connect(removeButton, SIGNAL(clicked()), tree, SLOT(removeOne()));
+    m_proxyModel->setSourceModel(m_bookmarksModel);
+    tree->setModel(m_proxyModel);
+    tree->setDragDropMode(QAbstractItemView::InternalMove);
+    tree->setExpanded(m_proxyModel->index(0, 0), true);
+    tree->setAlternatingRowColors(true);
+    QFontMetrics fm(font());
+    int header = fm.width(QLatin1Char('m')) * 40;
+    tree->header()->resizeSection(0, header);
+    tree->header()->setStretchLastSection(true);
+    connect(tree, SIGNAL(activated(const QModelIndex&)),
+            this, SLOT(open()));
+    tree->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(tree, SIGNAL(customContextMenuRequested(const QPoint &)),
+            this, SLOT(customContextMenuRequested(const QPoint &)));
+    connect(addFolderButton, SIGNAL(clicked()),
+            this, SLOT(newFolder()));
+    expandNodes(m_bookmarksManager->bookmarks());
+    setAttribute(Qt::WA_DeleteOnClose);
+}
+
+BookmarksDialog::~BookmarksDialog()
+{
+    if (saveExpandedNodes(tree->rootIndex()))
+        m_bookmarksManager->changeExpanded();
+}
+
+bool BookmarksDialog::saveExpandedNodes(const QModelIndex &parent)
+{
+    bool changed = false;
+    for (int i = 0; i < m_proxyModel->rowCount(parent); ++i) {
+        QModelIndex child = m_proxyModel->index(i, 0, parent);
+        QModelIndex sourceIndex = m_proxyModel->mapToSource(child);
+        BookmarkNode *childNode = m_bookmarksModel->node(sourceIndex);
+        bool wasExpanded = childNode->expanded;
+        if (tree->isExpanded(child)) {
+            childNode->expanded = true;
+            changed |= saveExpandedNodes(child);
+        } else {
+            childNode->expanded = false;
+        }
+        changed |= (wasExpanded != childNode->expanded);
+    }
+    return changed;
+}
+
+void BookmarksDialog::expandNodes(BookmarkNode *node)
+{
+    for (int i = 0; i < node->children().count(); ++i) {
+        BookmarkNode *childNode = node->children()[i];
+        if (childNode->expanded) {
+            QModelIndex idx = m_bookmarksModel->index(childNode);
+            idx = m_proxyModel->mapFromSource(idx);
+            tree->setExpanded(idx, true);
+            expandNodes(childNode);
+        }
+    }
+}
+
+void BookmarksDialog::customContextMenuRequested(const QPoint &pos)
+{
+    QMenu menu;
+    QModelIndex index = tree->indexAt(pos);
+    index = index.sibling(index.row(), 0);
+    if (index.isValid() && !tree->model()->hasChildren(index)) {
+        menu.addAction(tr("Open"), this, SLOT(open()));
+        menu.addSeparator();
+    }
+    menu.addAction(tr("Delete"), tree, SLOT(removeOne()));
+    menu.exec(QCursor::pos());
+}
+
+void BookmarksDialog::open()
+{
+    QModelIndex index = tree->currentIndex();
+    if (!index.parent().isValid())
+        return;
+    emit openUrl(index.sibling(index.row(), 1).data(BookmarksModel::UrlRole).toUrl());
+}
+
+void BookmarksDialog::newFolder()
+{
+    QModelIndex currentIndex = tree->currentIndex();
+    QModelIndex idx = currentIndex;
+    if (idx.isValid() && !idx.model()->hasChildren(idx))
+        idx = idx.parent();
+    if (!idx.isValid())
+        idx = tree->rootIndex();
+    idx = m_proxyModel->mapToSource(idx);
+    BookmarkNode *parent = m_bookmarksManager->bookmarksModel()->node(idx);
+    BookmarkNode *node = new BookmarkNode(BookmarkNode::Folder);
+    node->title = tr("New Folder");
+    m_bookmarksManager->addBookmark(parent, node, currentIndex.row() + 1);
+}
+
+BookmarksToolBar::BookmarksToolBar(BookmarksModel *model, QWidget *parent)
+    : QToolBar(tr("Bookmark"), parent)
+    , m_bookmarksModel(model)
+{
+    connect(this, SIGNAL(actionTriggered(QAction*)), this, SLOT(triggered(QAction*)));
+    setRootIndex(model->index(0, 0));
+    connect(m_bookmarksModel, SIGNAL(modelReset()), this, SLOT(build()));
+    connect(m_bookmarksModel, SIGNAL(rowsInserted(const QModelIndex &, int, int)), this, SLOT(build()));
+    connect(m_bookmarksModel, SIGNAL(rowsRemoved(const QModelIndex &, int, int)), this, SLOT(build()));
+    connect(m_bookmarksModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(build()));
+    setAcceptDrops(true);
+}
+
+void BookmarksToolBar::dragEnterEvent(QDragEnterEvent *event)
+{
+    const QMimeData *mimeData = event->mimeData();
+    if (mimeData->hasUrls())
+        event->acceptProposedAction();
+    QToolBar::dragEnterEvent(event);
+}
+
+void BookmarksToolBar::dropEvent(QDropEvent *event)
+{
+    const QMimeData *mimeData = event->mimeData();
+    if (mimeData->hasUrls() && mimeData->hasText()) {
+        QList<QUrl> urls = mimeData->urls();
+        QAction *action = actionAt(event->pos());
+        QString dropText;
+        if (action)
+            dropText = action->text();
+        int row = -1;
+        QModelIndex parentIndex = m_root;
+        for (int i = 0; i < m_bookmarksModel->rowCount(m_root); ++i) {
+            QModelIndex idx = m_bookmarksModel->index(i, 0, m_root);
+            QString title = idx.data().toString();
+            if (title == dropText) {
+                row = i;
+                if (m_bookmarksModel->hasChildren(idx)) {
+                    parentIndex = idx;
+                    row = -1;
+                }
+                break;
+            }
+        }
+        BookmarkNode *bookmark = new BookmarkNode(BookmarkNode::Bookmark);
+        bookmark->url = urls.at(0).toString();
+        bookmark->title = mimeData->text();
+
+        BookmarkNode *parent = m_bookmarksModel->node(parentIndex);
+        BookmarksManager *bookmarksManager = m_bookmarksModel->bookmarksManager();
+        bookmarksManager->addBookmark(parent, bookmark, row);
+        event->acceptProposedAction();
+    }
+    QToolBar::dropEvent(event);
+}
+
+
+void BookmarksToolBar::setRootIndex(const QModelIndex &index)
+{
+    m_root = index;
+    build();
+}
+
+QModelIndex BookmarksToolBar::rootIndex() const
+{
+    return m_root;
+}
+
+void BookmarksToolBar::build()
+{
+    clear();
+    for (int i = 0; i < m_bookmarksModel->rowCount(m_root); ++i) {
+        QModelIndex idx = m_bookmarksModel->index(i, 0, m_root);
+        if (m_bookmarksModel->hasChildren(idx)) {
+            QToolButton *button = new QToolButton(this);
+            button->setPopupMode(QToolButton::InstantPopup);
+            button->setArrowType(Qt::DownArrow);
+            button->setText(idx.data().toString());
+            ModelMenu *menu = new ModelMenu(this);
+            connect(menu, SIGNAL(activated(const QModelIndex &)),
+                    this, SLOT(activated(const QModelIndex &)));
+            menu->setModel(m_bookmarksModel);
+            menu->setRootIndex(idx);
+            menu->addAction(new QAction(menu));
+            button->setMenu(menu);
+            button->setToolButtonStyle(Qt::ToolButtonTextOnly);
+            QAction *a = addWidget(button);
+            a->setText(idx.data().toString());
+        } else {
+            QAction *action = addAction(idx.data().toString());
+            action->setData(idx.data(BookmarksModel::UrlRole));
+        }
+    }
+}
+
+void BookmarksToolBar::triggered(QAction *action)
+{
+    QVariant v = action->data();
+    if (v.canConvert<QUrl>()) {
+        emit openUrl(v.toUrl());
+    }
+}
+
+void BookmarksToolBar::activated(const QModelIndex &index)
+{
+    emit openUrl(index.data(BookmarksModel::UrlRole).toUrl());
+}
+
diff --git a/examples/gestures/browser/bookmarks.h b/examples/gestures/browser/bookmarks.h
new file mode 100644
index 0000000..b25ce8d
--- /dev/null
+++ b/examples/gestures/browser/bookmarks.h
@@ -0,0 +1,310 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef BOOKMARKS_H
+#define BOOKMARKS_H
+
+#include <QtCore/QObject>
+#include <QtCore/QAbstractItemModel>
+
+#include <QtGui/QUndoCommand>
+
+/*!
+    Bookmark manager, owner of the bookmarks, loads, saves and basic tasks
+  */
+class AutoSaver;
+class BookmarkNode;
+class BookmarksModel;
+class BookmarksManager : public QObject
+{
+    Q_OBJECT
+
+signals:
+    void entryAdded(BookmarkNode *item);
+    void entryRemoved(BookmarkNode *parent, int row, BookmarkNode *item);
+    void entryChanged(BookmarkNode *item);
+
+public:
+    BookmarksManager(QObject *parent = 0);
+    ~BookmarksManager();
+
+    void addBookmark(BookmarkNode *parent, BookmarkNode *node, int row = -1);
+    void removeBookmark(BookmarkNode *node);
+    void setTitle(BookmarkNode *node, const QString &newTitle);
+    void setUrl(BookmarkNode *node, const QString &newUrl);
+    void changeExpanded();
+
+    BookmarkNode *bookmarks();
+    BookmarkNode *menu();
+    BookmarkNode *toolbar();
+
+    BookmarksModel *bookmarksModel();
+    QUndoStack *undoRedoStack() { return &m_commands; };
+
+public slots:
+    void importBookmarks();
+    void exportBookmarks();
+
+private slots:
+    void save() const;
+
+private:
+    void load();
+
+    bool m_loaded;
+    AutoSaver *m_saveTimer;
+    BookmarkNode *m_bookmarkRootNode;
+    BookmarksModel *m_bookmarkModel;
+    QUndoStack m_commands;
+
+    friend class RemoveBookmarksCommand;
+    friend class ChangeBookmarkCommand;
+};
+
+class RemoveBookmarksCommand : public QUndoCommand
+{
+
+public:
+    RemoveBookmarksCommand(BookmarksManager *m_bookmarkManagaer, BookmarkNode *parent, int row);
+    ~RemoveBookmarksCommand();
+    void undo();
+    void redo();
+
+protected:
+    int m_row;
+    BookmarksManager *m_bookmarkManagaer;
+    BookmarkNode *m_node;
+    BookmarkNode *m_parent;
+    bool m_done;
+};
+
+class InsertBookmarksCommand : public RemoveBookmarksCommand
+{
+
+public:
+    InsertBookmarksCommand(BookmarksManager *m_bookmarkManagaer,
+        BookmarkNode *parent, BookmarkNode *node, int row);
+    void undo() { RemoveBookmarksCommand::redo(); }
+    void redo() { RemoveBookmarksCommand::undo(); }
+
+};
+
+class ChangeBookmarkCommand : public QUndoCommand
+{
+
+public:
+    ChangeBookmarkCommand(BookmarksManager *m_bookmarkManagaer,
+        BookmarkNode *node, const QString &newValue, bool title);
+    void undo();
+    void redo();
+
+private:
+    BookmarksManager *m_bookmarkManagaer;
+    bool m_title;
+    QString m_oldValue;
+    QString m_newValue;
+    BookmarkNode *m_node;
+};
+
+/*!
+    BookmarksModel is a QAbstractItemModel wrapper around the BookmarkManager
+  */
+#include <QtGui/QIcon>
+class BookmarksModel : public QAbstractItemModel
+{
+    Q_OBJECT
+
+public slots:
+    void entryAdded(BookmarkNode *item);
+    void entryRemoved(BookmarkNode *parent, int row, BookmarkNode *item);
+    void entryChanged(BookmarkNode *item);
+
+public:
+    enum Roles {
+        TypeRole = Qt::UserRole + 1,
+        UrlRole = Qt::UserRole + 2,
+        UrlStringRole = Qt::UserRole + 3,
+        SeparatorRole = Qt::UserRole + 4
+    };
+
+    BookmarksModel(BookmarksManager *bookmarkManager, QObject *parent = 0);
+    inline BookmarksManager *bookmarksManager() const { return m_bookmarksManager; }
+
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    QModelIndex index(int, int, const QModelIndex& = QModelIndex()) const;
+    QModelIndex parent(const QModelIndex& index= QModelIndex()) const;
+    Qt::ItemFlags flags(const QModelIndex &index) const;
+    Qt::DropActions supportedDropActions () const;
+    bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
+    bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole);
+    QMimeData *mimeData(const QModelIndexList &indexes) const;
+    QStringList mimeTypes() const;
+    bool dropMimeData(const QMimeData *data,
+        Qt::DropAction action, int row, int column, const QModelIndex &parent);
+    bool hasChildren(const QModelIndex &parent = QModelIndex()) const;
+
+    BookmarkNode *node(const QModelIndex &index) const;
+    QModelIndex index(BookmarkNode *node) const;
+
+private:
+
+    bool m_endMacro;
+    BookmarksManager *m_bookmarksManager;
+};
+
+// Menu that is dynamically populated from the bookmarks
+#include "modelmenu.h"
+class BookmarksMenu : public ModelMenu
+{
+    Q_OBJECT
+
+signals:
+    void openUrl(const QUrl &url);
+
+public:
+     BookmarksMenu(QWidget *parent = 0);
+     void setInitialActions(QList<QAction*> actions);
+
+protected:
+    bool prePopulated();
+
+private slots:
+    void activated(const QModelIndex &index);
+
+private:
+    BookmarksManager *m_bookmarksManager;
+    QList<QAction*> m_initialActions;
+};
+
+/*
+    Proxy model that filters out the bookmarks so only the folders
+    are left behind.  Used in the add bookmark dialog combobox.
+ */
+#include <QtGui/QSortFilterProxyModel>
+class AddBookmarkProxyModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+public:
+    AddBookmarkProxyModel(QObject * parent = 0);
+    int columnCount(const QModelIndex & parent = QModelIndex()) const;
+
+protected:
+    bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const;
+};
+
+/*!
+    Add bookmark dialog
+ */
+#include "ui_addbookmarkdialog.h"
+class AddBookmarkDialog : public QDialog, public Ui_AddBookmarkDialog
+{
+    Q_OBJECT
+
+public:
+    AddBookmarkDialog(const QString &url, const QString &title, QWidget *parent = 0, BookmarksManager *bookmarkManager = 0);
+
+private slots:
+    void accept();
+
+private:
+    QString m_url;
+    BookmarksManager *m_bookmarksManager;
+    AddBookmarkProxyModel *m_proxyModel;
+};
+
+#include "ui_bookmarks.h"
+class TreeProxyModel;
+class BookmarksDialog : public QDialog, public Ui_BookmarksDialog
+{
+    Q_OBJECT
+
+signals:
+    void openUrl(const QUrl &url);
+
+public:
+    BookmarksDialog(QWidget *parent = 0, BookmarksManager *manager = 0);
+    ~BookmarksDialog();
+
+private slots:
+    void customContextMenuRequested(const QPoint &pos);
+    void open();
+    void newFolder();
+
+private:
+    void expandNodes(BookmarkNode *node);
+    bool saveExpandedNodes(const QModelIndex &parent);
+
+    BookmarksManager *m_bookmarksManager;
+    BookmarksModel *m_bookmarksModel;
+    TreeProxyModel *m_proxyModel;
+};
+
+#include <QtGui/QToolBar>
+class BookmarksToolBar : public QToolBar
+{
+    Q_OBJECT
+
+signals:
+    void openUrl(const QUrl &url);
+
+public:
+    BookmarksToolBar(BookmarksModel *model, QWidget *parent = 0);
+    void setRootIndex(const QModelIndex &index);
+    QModelIndex rootIndex() const;
+
+protected:
+    void dragEnterEvent(QDragEnterEvent *event);
+    void dropEvent(QDropEvent *event);
+
+private slots:
+    void triggered(QAction *action);
+    void activated(const QModelIndex &index);
+    void build();
+
+private:
+    BookmarksModel *m_bookmarksModel;
+    QPersistentModelIndex m_root;
+};
+
+#endif // BOOKMARKS_H
diff --git a/examples/gestures/browser/bookmarks.ui b/examples/gestures/browser/bookmarks.ui
new file mode 100644
index 0000000..c893e94
--- /dev/null
+++ b/examples/gestures/browser/bookmarks.ui
@@ -0,0 +1,106 @@
+<ui version="4.0" >
+ <class>BookmarksDialog</class>
+ <widget class="QDialog" name="BookmarksDialog" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>758</width>
+    <height>450</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Bookmarks</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout" >
+   <item row="0" column="0" >
+    <spacer>
+     <property name="orientation" >
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="sizeHint" stdset="0" >
+      <size>
+       <width>252</width>
+       <height>20</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="0" column="1" >
+    <widget class="SearchLineEdit" name="search" />
+   </item>
+   <item row="1" column="0" colspan="2" >
+    <widget class="EditTreeView" name="tree" />
+   </item>
+   <item row="2" column="0" colspan="2" >
+    <layout class="QHBoxLayout" >
+     <item>
+      <widget class="QPushButton" name="removeButton" >
+       <property name="text" >
+        <string>&amp;Remove</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="addFolderButton" >
+       <property name="text" >
+        <string>Add Folder</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer>
+       <property name="orientation" >
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0" >
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QDialogButtonBox" name="buttonBox" >
+       <property name="standardButtons" >
+        <set>QDialogButtonBox::Ok</set>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>SearchLineEdit</class>
+   <extends>QLineEdit</extends>
+   <header>searchlineedit.h</header>
+  </customwidget>
+  <customwidget>
+   <class>EditTreeView</class>
+   <extends>QTreeView</extends>
+   <header>edittreeview.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>BookmarksDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel" >
+     <x>472</x>
+     <y>329</y>
+    </hint>
+    <hint type="destinationlabel" >
+     <x>461</x>
+     <y>356</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/examples/gestures/browser/browser.icns b/examples/gestures/browser/browser.icns
new file mode 100644
index 0000000..f591ae4
--- /dev/null
+++ b/examples/gestures/browser/browser.icns
diff --git a/examples/gestures/browser/browser.ico b/examples/gestures/browser/browser.ico
new file mode 100644
index 0000000..7f9be93
--- /dev/null
+++ b/examples/gestures/browser/browser.ico
diff --git a/examples/gestures/browser/browser.pro b/examples/gestures/browser/browser.pro
new file mode 100644
index 0000000..d970f99
--- /dev/null
+++ b/examples/gestures/browser/browser.pro
@@ -0,0 +1,91 @@
+TEMPLATE = app
+TARGET = browser
+QT += webkit network
+
+CONFIG += qt warn_on
+contains(QT_BUILD_PARTS, tools): CONFIG += uitools
+else: DEFINES += QT_NO_UITOOLS
+
+FORMS += \
+    addbookmarkdialog.ui \
+    bookmarks.ui \
+    cookies.ui \
+    cookiesexceptions.ui \
+    downloaditem.ui \
+    downloads.ui \
+    history.ui \
+    passworddialog.ui \
+    proxy.ui \
+    settings.ui
+
+HEADERS += \
+    autosaver.h \
+    bookmarks.h \
+    browserapplication.h \
+    browsermainwindow.h \
+    chasewidget.h \
+    cookiejar.h \
+    downloadmanager.h \
+    edittableview.h \
+    edittreeview.h \
+    history.h \
+    modelmenu.h \
+    networkaccessmanager.h \
+    searchlineedit.h \
+    settings.h \
+    squeezelabel.h \
+    tabwidget.h \
+    toolbarsearch.h \
+    urllineedit.h \
+    webview.h \
+    xbel.h
+
+SOURCES += \
+    autosaver.cpp \
+    bookmarks.cpp \
+    browserapplication.cpp \
+    browsermainwindow.cpp \
+    chasewidget.cpp \
+    cookiejar.cpp \
+    downloadmanager.cpp \
+    edittableview.cpp \
+    edittreeview.cpp \
+    history.cpp \
+    modelmenu.cpp \
+    networkaccessmanager.cpp \
+    searchlineedit.cpp \
+    settings.cpp \
+    squeezelabel.cpp \
+    tabwidget.cpp \
+    toolbarsearch.cpp \
+    urllineedit.cpp \
+    webview.cpp \
+    xbel.cpp \
+    main.cpp
+
+RESOURCES += data/data.qrc htmls/htmls.qrc
+
+build_all:!build_pass {
+    CONFIG -= build_all
+    CONFIG += release
+}
+
+win32 {
+   RC_FILE = browser.rc
+}
+
+mac {
+    ICON = browser.icns
+    QMAKE_INFO_PLIST = Info_mac.plist
+    TARGET = Browser
+}
+
+wince*: {
+    DEPLOYMENT_PLUGIN += qjpeg qgif
+}
+
+# install
+target.path = $$[QT_INSTALL_DEMOS]/browser
+sources.files = $$SOURCES $$HEADERS $$RESOURCES $$FORMS *.plist *.icns *.ico *.rc *.pro *.html *.doc images htmls
+sources.path = $$[QT_INSTALL_DEMOS]/browser
+INSTALLS += target sources
diff --git a/examples/gestures/browser/browser.rc b/examples/gestures/browser/browser.rc
new file mode 100644
index 0000000..89a237c
--- /dev/null
+++ b/examples/gestures/browser/browser.rc
@@ -0,0 +1,2 @@
+IDI_ICON1               ICON    DISCARDABLE     "browser.ico"
+
diff --git a/examples/gestures/browser/browserapplication.cpp b/examples/gestures/browser/browserapplication.cpp
new file mode 100644
index 0000000..5a1d880
--- /dev/null
+++ b/examples/gestures/browser/browserapplication.cpp
@@ -0,0 +1,447 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "browserapplication.h"
+
+#include "bookmarks.h"
+#include "browsermainwindow.h"
+#include "cookiejar.h"
+#include "downloadmanager.h"
+#include "history.h"
+#include "networkaccessmanager.h"
+#include "tabwidget.h"
+#include "webview.h"
+
+#include <QtCore/QBuffer>
+#include <QtCore/QDir>
+#include <QtCore/QLibraryInfo>
+#include <QtCore/QSettings>
+#include <QtCore/QTextStream>
+#include <QtCore/QTranslator>
+
+#include <QtGui/QDesktopServices>
+#include <QtGui/QFileOpenEvent>
+
+#include <QtNetwork/QLocalServer>
+#include <QtNetwork/QLocalSocket>
+#include <QtNetwork/QNetworkProxy>
+
+#include <QtWebKit/QWebSettings>
+
+#include <QtCore/QDebug>
+
+DownloadManager *BrowserApplication::s_downloadManager = 0;
+HistoryManager *BrowserApplication::s_historyManager = 0;
+NetworkAccessManager *BrowserApplication::s_networkAccessManager = 0;
+BookmarksManager *BrowserApplication::s_bookmarksManager = 0;
+
+BrowserApplication::BrowserApplication(int &argc, char **argv)
+    : QApplication(argc, argv)
+    , m_localServer(0)
+{
+    QCoreApplication::setOrganizationName(QLatin1String("Trolltech"));
+    QCoreApplication::setApplicationName(QLatin1String("demobrowser"));
+    QCoreApplication::setApplicationVersion(QLatin1String("0.1"));
+#ifdef Q_WS_QWS
+    // Use a different server name for QWS so we can run an X11
+    // browser and a QWS browser in parallel on the same machine for
+    // debugging
+    QString serverName = QCoreApplication::applicationName() + QLatin1String("_qws");
+#else
+    QString serverName = QCoreApplication::applicationName();
+#endif
+    QLocalSocket socket;
+    socket.connectToServer(serverName);
+    if (socket.waitForConnected(500)) {
+        QTextStream stream(&socket);
+        QStringList args = QCoreApplication::arguments();
+        if (args.count() > 1)
+            stream << args.last();
+        else
+            stream << QString();
+        stream.flush();
+        socket.waitForBytesWritten();
+        return;
+    }
+
+#if defined(Q_WS_MAC)
+    QApplication::setQuitOnLastWindowClosed(false);
+#else
+    QApplication::setQuitOnLastWindowClosed(true);
+#endif
+
+    m_localServer = new QLocalServer(this);
+    connect(m_localServer, SIGNAL(newConnection()),
+            this, SLOT(newLocalSocketConnection()));
+    if (!m_localServer->listen(serverName)) {
+        if (m_localServer->serverError() == QAbstractSocket::AddressInUseError
+            && QFile::exists(m_localServer->serverName())) {
+            QFile::remove(m_localServer->serverName());
+            m_localServer->listen(serverName);
+        }
+    }
+
+    QDesktopServices::setUrlHandler(QLatin1String("http"), this, "openUrl");
+    QString localSysName = QLocale::system().name();
+
+    installTranslator(QLatin1String("qt_") + localSysName);
+
+    QSettings settings;
+    settings.beginGroup(QLatin1String("sessions"));
+    m_lastSession = settings.value(QLatin1String("lastSession")).toByteArray();
+    settings.endGroup();
+
+#if defined(Q_WS_MAC)
+    connect(this, SIGNAL(lastWindowClosed()),
+            this, SLOT(lastWindowClosed()));
+#endif
+
+    QTimer::singleShot(0, this, SLOT(postLaunch()));
+}
+
+BrowserApplication::~BrowserApplication()
+{
+    delete s_downloadManager;
+    for (int i = 0; i < m_mainWindows.size(); ++i) {
+        BrowserMainWindow *window = m_mainWindows.at(i);
+        delete window;
+    }
+    delete s_networkAccessManager;
+    delete s_bookmarksManager;
+}
+
+#if defined(Q_WS_MAC)
+void BrowserApplication::lastWindowClosed()
+{
+    clean();
+    BrowserMainWindow *mw = new BrowserMainWindow;
+    mw->slotHome();
+    m_mainWindows.prepend(mw);
+}
+#endif
+
+BrowserApplication *BrowserApplication::instance()
+{
+    return (static_cast<BrowserApplication *>(QCoreApplication::instance()));
+}
+
+#if defined(Q_WS_MAC)
+#include <QtGui/QMessageBox>
+void BrowserApplication::quitBrowser()
+{
+    clean();
+    int tabCount = 0;
+    for (int i = 0; i < m_mainWindows.count(); ++i) {
+        tabCount =+ m_mainWindows.at(i)->tabWidget()->count();
+    }
+
+    if (tabCount > 1) {
+        int ret = QMessageBox::warning(mainWindow(), QString(),
+                           tr("There are %1 windows and %2 tabs open\n"
+                              "Do you want to quit anyway?").arg(m_mainWindows.count()).arg(tabCount),
+                           QMessageBox::Yes | QMessageBox::No,
+                           QMessageBox::No);
+        if (ret == QMessageBox::No)
+            return;
+    }
+
+    exit(0);
+}
+#endif
+
+/*!
+    Any actions that can be delayed until the window is visible
+ */
+void BrowserApplication::postLaunch()
+{
+    QString directory = QDesktopServices::storageLocation(QDesktopServices::DataLocation);
+    if (directory.isEmpty())
+        directory = QDir::homePath() + QLatin1String("/.") + QCoreApplication::applicationName();
+    QWebSettings::setIconDatabasePath(directory);
+
+    setWindowIcon(QIcon(QLatin1String(":browser.svg")));
+
+    loadSettings();
+
+    // newMainWindow() needs to be called in main() for this to happen
+    if (m_mainWindows.count() > 0) {
+        QStringList args = QCoreApplication::arguments();
+        if (args.count() > 1)
+            mainWindow()->loadPage(args.last());
+        else
+            mainWindow()->slotHome();
+    }
+    BrowserApplication::historyManager();
+}
+
+void BrowserApplication::loadSettings()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("websettings"));
+
+    QWebSettings *defaultSettings = QWebSettings::globalSettings();
+    QString standardFontFamily = defaultSettings->fontFamily(QWebSettings::StandardFont);
+    int standardFontSize = defaultSettings->fontSize(QWebSettings::DefaultFontSize);
+    QFont standardFont = QFont(standardFontFamily, standardFontSize);
+    standardFont = qVariantValue<QFont>(settings.value(QLatin1String("standardFont"), standardFont));
+    defaultSettings->setFontFamily(QWebSettings::StandardFont, standardFont.family());
+    defaultSettings->setFontSize(QWebSettings::DefaultFontSize, standardFont.pointSize());
+
+    QString fixedFontFamily = defaultSettings->fontFamily(QWebSettings::FixedFont);
+    int fixedFontSize = defaultSettings->fontSize(QWebSettings::DefaultFixedFontSize);
+    QFont fixedFont = QFont(fixedFontFamily, fixedFontSize);
+    fixedFont = qVariantValue<QFont>(settings.value(QLatin1String("fixedFont"), fixedFont));
+    defaultSettings->setFontFamily(QWebSettings::FixedFont, fixedFont.family());
+    defaultSettings->setFontSize(QWebSettings::DefaultFixedFontSize, fixedFont.pointSize());
+
+    defaultSettings->setAttribute(QWebSettings::JavascriptEnabled, settings.value(QLatin1String("enableJavascript"), true).toBool());
+    defaultSettings->setAttribute(QWebSettings::PluginsEnabled, settings.value(QLatin1String("enablePlugins"), true).toBool());
+
+    QUrl url = settings.value(QLatin1String("userStyleSheet")).toUrl();
+    defaultSettings->setUserStyleSheetUrl(url);
+
+    settings.endGroup();
+}
+
+QList<BrowserMainWindow*> BrowserApplication::mainWindows()
+{
+    clean();
+    QList<BrowserMainWindow*> list;
+    for (int i = 0; i < m_mainWindows.count(); ++i)
+        list.append(m_mainWindows.at(i));
+    return list;
+}
+
+void BrowserApplication::clean()
+{
+    // cleanup any deleted main windows first
+    for (int i = m_mainWindows.count() - 1; i >= 0; --i)
+        if (m_mainWindows.at(i).isNull())
+            m_mainWindows.removeAt(i);
+}
+
+void BrowserApplication::saveSession()
+{
+    QWebSettings *globalSettings = QWebSettings::globalSettings();
+    if (globalSettings->testAttribute(QWebSettings::PrivateBrowsingEnabled))
+        return;
+
+    clean();
+
+    QSettings settings;
+    settings.beginGroup(QLatin1String("sessions"));
+
+    QByteArray data;
+    QBuffer buffer(&data);
+    QDataStream stream(&buffer);
+    buffer.open(QIODevice::ReadWrite);
+
+    stream << m_mainWindows.count();
+    for (int i = 0; i < m_mainWindows.count(); ++i)
+        stream << m_mainWindows.at(i)->saveState();
+    settings.setValue(QLatin1String("lastSession"), data);
+    settings.endGroup();
+}
+
+bool BrowserApplication::canRestoreSession() const
+{
+    return !m_lastSession.isEmpty();
+}
+
+void BrowserApplication::restoreLastSession()
+{
+    QList<QByteArray> windows;
+    QBuffer buffer(&m_lastSession);
+    QDataStream stream(&buffer);
+    buffer.open(QIODevice::ReadOnly);
+    int windowCount;
+    stream >> windowCount;
+    for (int i = 0; i < windowCount; ++i) {
+        QByteArray windowState;
+        stream >> windowState;
+        windows.append(windowState);
+    }
+    for (int i = 0; i < windows.count(); ++i) {
+        BrowserMainWindow *newWindow = 0;
+        if (m_mainWindows.count() == 1
+            && mainWindow()->tabWidget()->count() == 1
+            && mainWindow()->currentTab()->url() == QUrl()) {
+            newWindow = mainWindow();
+        } else {
+            newWindow = newMainWindow();
+        }
+        newWindow->restoreState(windows.at(i));
+    }
+}
+
+bool BrowserApplication::isTheOnlyBrowser() const
+{
+    return (m_localServer != 0);
+}
+
+void BrowserApplication::installTranslator(const QString &name)
+{
+    QTranslator *translator = new QTranslator(this);
+    translator->load(name, QLibraryInfo::location(QLibraryInfo::TranslationsPath));
+    QApplication::installTranslator(translator);
+}
+
+#if defined(Q_WS_MAC)
+bool BrowserApplication::event(QEvent* event)
+{
+    switch (event->type()) {
+    case QEvent::ApplicationActivate: {
+        clean();
+        if (!m_mainWindows.isEmpty()) {
+            BrowserMainWindow *mw = mainWindow();
+            if (mw && !mw->isMinimized()) {
+                mainWindow()->show();
+            }
+            return true;
+        }
+    }
+    case QEvent::FileOpen:
+        if (!m_mainWindows.isEmpty()) {
+            mainWindow()->loadPage(static_cast<QFileOpenEvent *>(event)->file());
+            return true;
+        }
+    default:
+        break;
+    }
+    return QApplication::event(event);
+}
+#endif
+
+void BrowserApplication::openUrl(const QUrl &url)
+{
+    mainWindow()->loadPage(url.toString());
+}
+
+BrowserMainWindow *BrowserApplication::newMainWindow()
+{
+    BrowserMainWindow *browser = new BrowserMainWindow();
+    m_mainWindows.prepend(browser);
+    browser->show();
+    return browser;
+}
+
+BrowserMainWindow *BrowserApplication::mainWindow()
+{
+    clean();
+    if (m_mainWindows.isEmpty())
+        newMainWindow();
+    return m_mainWindows[0];
+}
+
+void BrowserApplication::newLocalSocketConnection()
+{
+    QLocalSocket *socket = m_localServer->nextPendingConnection();
+    if (!socket)
+        return;
+    socket->waitForReadyRead(1000);
+    QTextStream stream(socket);
+    QString url;
+    stream >> url;
+    if (!url.isEmpty()) {
+        QSettings settings;
+        settings.beginGroup(QLatin1String("general"));
+        int openLinksIn = settings.value(QLatin1String("openLinksIn"), 0).toInt();
+        settings.endGroup();
+        if (openLinksIn == 1)
+            newMainWindow();
+        else
+            mainWindow()->tabWidget()->newTab();
+        openUrl(url);
+    }
+    delete socket;
+    mainWindow()->raise();
+    mainWindow()->activateWindow();
+}
+
+CookieJar *BrowserApplication::cookieJar()
+{
+    return (CookieJar*)networkAccessManager()->cookieJar();
+}
+
+DownloadManager *BrowserApplication::downloadManager()
+{
+    if (!s_downloadManager) {
+        s_downloadManager = new DownloadManager();
+    }
+    return s_downloadManager;
+}
+
+NetworkAccessManager *BrowserApplication::networkAccessManager()
+{
+    if (!s_networkAccessManager) {
+        s_networkAccessManager = new NetworkAccessManager();
+        s_networkAccessManager->setCookieJar(new CookieJar);
+    }
+    return s_networkAccessManager;
+}
+
+HistoryManager *BrowserApplication::historyManager()
+{
+    if (!s_historyManager) {
+        s_historyManager = new HistoryManager();
+        QWebHistoryInterface::setDefaultInterface(s_historyManager);
+    }
+    return s_historyManager;
+}
+
+BookmarksManager *BrowserApplication::bookmarksManager()
+{
+    if (!s_bookmarksManager) {
+        s_bookmarksManager = new BookmarksManager;
+    }
+    return s_bookmarksManager;
+}
+
+QIcon BrowserApplication::icon(const QUrl &url) const
+{
+    QIcon icon = QWebSettings::iconForUrl(url);
+    if (!icon.isNull())
+        return icon.pixmap(16, 16);
+    if (m_defaultIcon.isNull())
+        m_defaultIcon = QIcon(QLatin1String(":defaulticon.png"));
+    return m_defaultIcon.pixmap(16, 16);
+}
+
diff --git a/examples/gestures/browser/browserapplication.h b/examples/gestures/browser/browserapplication.h
new file mode 100644
index 0000000..6ab8abb
--- /dev/null
+++ b/examples/gestures/browser/browserapplication.h
@@ -0,0 +1,119 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef BROWSERAPPLICATION_H
+#define BROWSERAPPLICATION_H
+
+#include <QtGui/QApplication>
+
+#include <QtCore/QUrl>
+#include <QtCore/QPointer>
+
+#include <QtGui/QIcon>
+
+QT_BEGIN_NAMESPACE
+class QLocalServer;
+QT_END_NAMESPACE
+
+class BookmarksManager;
+class BrowserMainWindow;
+class CookieJar;
+class DownloadManager;
+class HistoryManager;
+class NetworkAccessManager;
+class BrowserApplication : public QApplication
+{
+    Q_OBJECT
+
+public:
+    BrowserApplication(int &argc, char **argv);
+    ~BrowserApplication();
+    static BrowserApplication *instance();
+    void loadSettings();
+
+    bool isTheOnlyBrowser() const;
+    BrowserMainWindow *mainWindow();
+    QList<BrowserMainWindow*> mainWindows();
+    QIcon icon(const QUrl &url) const;
+
+    void saveSession();
+    bool canRestoreSession() const;
+
+    static HistoryManager *historyManager();
+    static CookieJar *cookieJar();
+    static DownloadManager *downloadManager();
+    static NetworkAccessManager *networkAccessManager();
+    static BookmarksManager *bookmarksManager();
+
+#if defined(Q_WS_MAC)
+    bool event(QEvent *event);
+#endif
+
+public slots:
+    BrowserMainWindow *newMainWindow();
+    void restoreLastSession();
+#if defined(Q_WS_MAC)
+    void lastWindowClosed();
+    void quitBrowser();
+#endif
+
+private slots:
+    void postLaunch();
+    void openUrl(const QUrl &url);
+    void newLocalSocketConnection();
+
+private:
+    void clean();
+    void installTranslator(const QString &name);
+
+    static HistoryManager *s_historyManager;
+    static DownloadManager *s_downloadManager;
+    static NetworkAccessManager *s_networkAccessManager;
+    static BookmarksManager *s_bookmarksManager;
+
+    QList<QPointer<BrowserMainWindow> > m_mainWindows;
+    QLocalServer *m_localServer;
+    QByteArray m_lastSession;
+    mutable QIcon m_defaultIcon;
+};
+
+#endif // BROWSERAPPLICATION_H
+
diff --git a/examples/gestures/browser/browsermainwindow.cpp b/examples/gestures/browser/browsermainwindow.cpp
new file mode 100644
index 0000000..321adf2
--- /dev/null
+++ b/examples/gestures/browser/browsermainwindow.cpp
@@ -0,0 +1,991 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "browsermainwindow.h"
+
+#include "autosaver.h"
+#include "bookmarks.h"
+#include "browserapplication.h"
+#include "chasewidget.h"
+#include "downloadmanager.h"
+#include "history.h"
+#include "settings.h"
+#include "tabwidget.h"
+#include "toolbarsearch.h"
+#include "ui_passworddialog.h"
+#include "webview.h"
+
+#include <QtCore/QSettings>
+
+#include <QtGui/QDesktopWidget>
+#include <QtGui/QFileDialog>
+#include <QtGui/QPlainTextEdit>
+#include <QtGui/QPrintDialog>
+#include <QtGui/QPrintPreviewDialog>
+#include <QtGui/QPrinter>
+#include <QtGui/QMenuBar>
+#include <QtGui/QMessageBox>
+#include <QtGui/QStatusBar>
+#include <QtGui/QToolBar>
+#include <QtGui/QInputDialog>
+
+#include <QtWebKit/QWebFrame>
+#include <QtWebKit/QWebHistory>
+
+#include <QtCore/QDebug>
+
+BrowserMainWindow::BrowserMainWindow(QWidget *parent, Qt::WindowFlags flags)
+    : QMainWindow(parent, flags)
+    , m_tabWidget(new TabWidget(this))
+    , m_autoSaver(new AutoSaver(this))
+    , m_historyBack(0)
+    , m_historyForward(0)
+    , m_stop(0)
+    , m_reload(0)
+{
+    setAttribute(Qt::WA_DeleteOnClose, true);
+    statusBar()->setSizeGripEnabled(true);
+    setupMenu();
+    setupToolBar();
+
+    QWidget *centralWidget = new QWidget(this);
+    BookmarksModel *boomarksModel = BrowserApplication::bookmarksManager()->bookmarksModel();
+    m_bookmarksToolbar = new BookmarksToolBar(boomarksModel, this);
+    connect(m_bookmarksToolbar, SIGNAL(openUrl(const QUrl&)),
+            m_tabWidget, SLOT(loadUrlInCurrentTab(const QUrl&)));
+    connect(m_bookmarksToolbar->toggleViewAction(), SIGNAL(toggled(bool)),
+            this, SLOT(updateBookmarksToolbarActionText(bool)));
+
+    QVBoxLayout *layout = new QVBoxLayout;
+    layout->setSpacing(0);
+    layout->setMargin(0);
+#if defined(Q_WS_MAC)
+    layout->addWidget(m_bookmarksToolbar);
+    layout->addWidget(new QWidget); // <- OS X tab widget style bug
+#else
+    addToolBarBreak();
+    addToolBar(m_bookmarksToolbar);
+#endif
+    layout->addWidget(m_tabWidget);
+    centralWidget->setLayout(layout);
+	setCentralWidget(centralWidget);
+
+    connect(m_tabWidget, SIGNAL(loadPage(const QString &)),
+        this, SLOT(loadPage(const QString &)));
+    connect(m_tabWidget, SIGNAL(setCurrentTitle(const QString &)),
+        this, SLOT(slotUpdateWindowTitle(const QString &)));
+    connect(m_tabWidget, SIGNAL(showStatusBarMessage(const QString&)),
+            statusBar(), SLOT(showMessage(const QString&)));
+    connect(m_tabWidget, SIGNAL(linkHovered(const QString&)),
+            statusBar(), SLOT(showMessage(const QString&)));
+    connect(m_tabWidget, SIGNAL(loadProgress(int)),
+            this, SLOT(slotLoadProgress(int)));
+    connect(m_tabWidget, SIGNAL(tabsChanged()),
+            m_autoSaver, SLOT(changeOccurred()));
+    connect(m_tabWidget, SIGNAL(geometryChangeRequested(const QRect &)),
+            this, SLOT(geometryChangeRequested(const QRect &)));
+    connect(m_tabWidget, SIGNAL(printRequested(QWebFrame *)),
+            this, SLOT(printRequested(QWebFrame *)));
+    connect(m_tabWidget, SIGNAL(menuBarVisibilityChangeRequested(bool)),
+            menuBar(), SLOT(setVisible(bool)));
+    connect(m_tabWidget, SIGNAL(statusBarVisibilityChangeRequested(bool)),
+            statusBar(), SLOT(setVisible(bool)));
+    connect(m_tabWidget, SIGNAL(toolBarVisibilityChangeRequested(bool)),
+            m_navigationBar, SLOT(setVisible(bool)));
+    connect(m_tabWidget, SIGNAL(toolBarVisibilityChangeRequested(bool)),
+            m_bookmarksToolbar, SLOT(setVisible(bool)));
+#if defined(Q_WS_MAC)
+    connect(m_tabWidget, SIGNAL(lastTabClosed()),
+            this, SLOT(close()));
+#else
+    connect(m_tabWidget, SIGNAL(lastTabClosed()),
+            m_tabWidget, SLOT(newTab()));
+#endif
+
+    slotUpdateWindowTitle();
+    loadDefaultState();
+    m_tabWidget->newTab();
+
+    int size = m_tabWidget->lineEditStack()->sizeHint().height();
+    m_navigationBar->setIconSize(QSize(size, size));
+
+}
+
+BrowserMainWindow::~BrowserMainWindow()
+{
+    m_autoSaver->changeOccurred();
+    m_autoSaver->saveIfNeccessary();
+}
+
+void BrowserMainWindow::loadDefaultState()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("BrowserMainWindow"));
+    QByteArray data = settings.value(QLatin1String("defaultState")).toByteArray();
+    restoreState(data);
+    settings.endGroup();
+}
+
+QSize BrowserMainWindow::sizeHint() const
+{
+    QRect desktopRect = QApplication::desktop()->screenGeometry();
+    QSize size = desktopRect.size() * qreal(0.9);
+    return size;
+}
+
+void BrowserMainWindow::save()
+{
+    BrowserApplication::instance()->saveSession();
+
+    QSettings settings;
+    settings.beginGroup(QLatin1String("BrowserMainWindow"));
+    QByteArray data = saveState(false);
+    settings.setValue(QLatin1String("defaultState"), data);
+    settings.endGroup();
+}
+
+static const qint32 BrowserMainWindowMagic = 0xba;
+
+QByteArray BrowserMainWindow::saveState(bool withTabs) const
+{
+    int version = 2;
+    QByteArray data;
+    QDataStream stream(&data, QIODevice::WriteOnly);
+
+    stream << qint32(BrowserMainWindowMagic);
+    stream << qint32(version);
+
+    stream << size();
+    stream << !m_navigationBar->isHidden();
+    stream << !m_bookmarksToolbar->isHidden();
+    stream << !statusBar()->isHidden();
+    if (withTabs)
+        stream << tabWidget()->saveState();
+    else
+        stream << QByteArray();
+    return data;
+}
+
+bool BrowserMainWindow::restoreState(const QByteArray &state)
+{
+    int version = 2;
+    QByteArray sd = state;
+    QDataStream stream(&sd, QIODevice::ReadOnly);
+    if (stream.atEnd())
+        return false;
+
+    qint32 marker;
+    qint32 v;
+    stream >> marker;
+    stream >> v;
+    if (marker != BrowserMainWindowMagic || v != version)
+        return false;
+
+    QSize size;
+    bool showToolbar;
+    bool showBookmarksBar;
+    bool showStatusbar;
+    QByteArray tabState;
+
+    stream >> size;
+    stream >> showToolbar;
+    stream >> showBookmarksBar;
+    stream >> showStatusbar;
+    stream >> tabState;
+
+    resize(size);
+
+    m_navigationBar->setVisible(showToolbar);
+    updateToolbarActionText(showToolbar);
+
+    m_bookmarksToolbar->setVisible(showBookmarksBar);
+    updateBookmarksToolbarActionText(showBookmarksBar);
+
+    statusBar()->setVisible(showStatusbar);
+    updateStatusbarActionText(showStatusbar);
+
+    if (!tabWidget()->restoreState(tabState))
+        return false;
+
+    return true;
+}
+
+void BrowserMainWindow::setupMenu()
+{
+    new QShortcut(QKeySequence(Qt::Key_F6), this, SLOT(slotSwapFocus()));
+
+    // File
+    QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
+
+    fileMenu->addAction(tr("&New Window"), this, SLOT(slotFileNew()), QKeySequence::New);
+    fileMenu->addAction(m_tabWidget->newTabAction());
+    fileMenu->addAction(tr("&Open File..."), this, SLOT(slotFileOpen()), QKeySequence::Open);
+    fileMenu->addAction(tr("Open &Location..."), this,
+                SLOT(slotSelectLineEdit()), QKeySequence(Qt::ControlModifier + Qt::Key_L));
+    fileMenu->addSeparator();
+    fileMenu->addAction(m_tabWidget->closeTabAction());
+    fileMenu->addSeparator();
+    fileMenu->addAction(tr("&Save As..."), this,
+                SLOT(slotFileSaveAs()), QKeySequence(QKeySequence::Save));
+    fileMenu->addSeparator();
+    BookmarksManager *bookmarksManager = BrowserApplication::bookmarksManager();
+    fileMenu->addAction(tr("&Import Bookmarks..."), bookmarksManager, SLOT(importBookmarks()));
+    fileMenu->addAction(tr("&Export Bookmarks..."), bookmarksManager, SLOT(exportBookmarks()));
+    fileMenu->addSeparator();
+    fileMenu->addAction(tr("P&rint Preview..."), this, SLOT(slotFilePrintPreview()));
+    fileMenu->addAction(tr("&Print..."), this, SLOT(slotFilePrint()), QKeySequence::Print);
+    fileMenu->addSeparator();
+    QAction *action = fileMenu->addAction(tr("Private &Browsing..."), this, SLOT(slotPrivateBrowsing()));
+    action->setCheckable(true);
+    fileMenu->addSeparator();
+
+#if defined(Q_WS_MAC)
+    fileMenu->addAction(tr("&Quit"), BrowserApplication::instance(), SLOT(quitBrowser()), QKeySequence(Qt::CTRL | Qt::Key_Q));
+#else
+    fileMenu->addAction(tr("&Quit"), this, SLOT(close()), QKeySequence(Qt::CTRL | Qt::Key_Q));
+#endif
+
+    // Edit
+    QMenu *editMenu = menuBar()->addMenu(tr("&Edit"));
+    QAction *m_undo = editMenu->addAction(tr("&Undo"));
+    m_undo->setShortcuts(QKeySequence::Undo);
+    m_tabWidget->addWebAction(m_undo, QWebPage::Undo);
+    QAction *m_redo = editMenu->addAction(tr("&Redo"));
+    m_redo->setShortcuts(QKeySequence::Redo);
+    m_tabWidget->addWebAction(m_redo, QWebPage::Redo);
+    editMenu->addSeparator();
+    QAction *m_cut = editMenu->addAction(tr("Cu&t"));
+    m_cut->setShortcuts(QKeySequence::Cut);
+    m_tabWidget->addWebAction(m_cut, QWebPage::Cut);
+    QAction *m_copy = editMenu->addAction(tr("&Copy"));
+    m_copy->setShortcuts(QKeySequence::Copy);
+    m_tabWidget->addWebAction(m_copy, QWebPage::Copy);
+    QAction *m_paste = editMenu->addAction(tr("&Paste"));
+    m_paste->setShortcuts(QKeySequence::Paste);
+    m_tabWidget->addWebAction(m_paste, QWebPage::Paste);
+    editMenu->addSeparator();
+
+    QAction *m_find = editMenu->addAction(tr("&Find"));
+    m_find->setShortcuts(QKeySequence::Find);
+    connect(m_find, SIGNAL(triggered()), this, SLOT(slotEditFind()));
+    new QShortcut(QKeySequence(Qt::Key_Slash), this, SLOT(slotEditFind()));
+
+    QAction *m_findNext = editMenu->addAction(tr("&Find Next"));
+    m_findNext->setShortcuts(QKeySequence::FindNext);
+    connect(m_findNext, SIGNAL(triggered()), this, SLOT(slotEditFindNext()));
+
+    QAction *m_findPrevious = editMenu->addAction(tr("&Find Previous"));
+    m_findPrevious->setShortcuts(QKeySequence::FindPrevious);
+    connect(m_findPrevious, SIGNAL(triggered()), this, SLOT(slotEditFindPrevious()));
+
+    editMenu->addSeparator();
+    editMenu->addAction(tr("&Preferences"), this, SLOT(slotPreferences()), tr("Ctrl+,"));
+
+    // View
+    QMenu *viewMenu = menuBar()->addMenu(tr("&View"));
+
+    m_viewBookmarkBar = new QAction(this);
+    updateBookmarksToolbarActionText(true);
+    m_viewBookmarkBar->setShortcut(tr("Shift+Ctrl+B"));
+    connect(m_viewBookmarkBar, SIGNAL(triggered()), this, SLOT(slotViewBookmarksBar()));
+    viewMenu->addAction(m_viewBookmarkBar);
+
+    m_viewToolbar = new QAction(this);
+    updateToolbarActionText(true);
+    m_viewToolbar->setShortcut(tr("Ctrl+|"));
+    connect(m_viewToolbar, SIGNAL(triggered()), this, SLOT(slotViewToolbar()));
+    viewMenu->addAction(m_viewToolbar);
+
+    m_viewStatusbar = new QAction(this);
+    updateStatusbarActionText(true);
+    m_viewStatusbar->setShortcut(tr("Ctrl+/"));
+    connect(m_viewStatusbar, SIGNAL(triggered()), this, SLOT(slotViewStatusbar()));
+    viewMenu->addAction(m_viewStatusbar);
+
+    viewMenu->addSeparator();
+
+    m_stop = viewMenu->addAction(tr("&Stop"));
+    QList<QKeySequence> shortcuts;
+    shortcuts.append(QKeySequence(Qt::CTRL | Qt::Key_Period));
+    shortcuts.append(Qt::Key_Escape);
+    m_stop->setShortcuts(shortcuts);
+    m_tabWidget->addWebAction(m_stop, QWebPage::Stop);
+
+    m_reload = viewMenu->addAction(tr("Reload Page"));
+    m_reload->setShortcuts(QKeySequence::Refresh);
+    m_tabWidget->addWebAction(m_reload, QWebPage::Reload);
+
+    viewMenu->addAction(tr("Zoom &In"), this, SLOT(slotViewZoomIn()), QKeySequence(Qt::CTRL | Qt::Key_Plus));
+    viewMenu->addAction(tr("Zoom &Out"), this, SLOT(slotViewZoomOut()), QKeySequence(Qt::CTRL | Qt::Key_Minus));
+    viewMenu->addAction(tr("Reset &Zoom"), this, SLOT(slotViewResetZoom()), QKeySequence(Qt::CTRL | Qt::Key_0));
+    QAction *zoomTextOnlyAction = viewMenu->addAction(tr("Zoom &Text Only"));
+    connect(zoomTextOnlyAction, SIGNAL(toggled(bool)), this, SLOT(slotViewZoomTextOnly(bool)));
+    zoomTextOnlyAction->setCheckable(true);
+    zoomTextOnlyAction->setChecked(false);
+
+    viewMenu->addSeparator();
+    viewMenu->addAction(tr("Page S&ource"), this, SLOT(slotViewPageSource()), tr("Ctrl+Alt+U"));
+    QAction *a = viewMenu->addAction(tr("&Full Screen"), this, SLOT(slotViewFullScreen(bool)),  Qt::Key_F11);
+    a->setCheckable(true);
+
+    // History
+    HistoryMenu *historyMenu = new HistoryMenu(this);
+    connect(historyMenu, SIGNAL(openUrl(const QUrl&)),
+            m_tabWidget, SLOT(loadUrlInCurrentTab(const QUrl&)));
+    connect(historyMenu, SIGNAL(hovered(const QString&)), this,
+            SLOT(slotUpdateStatusbar(const QString&)));
+    historyMenu->setTitle(tr("Hi&story"));
+    menuBar()->addMenu(historyMenu);
+    QList<QAction*> historyActions;
+
+    m_historyBack = new QAction(tr("Back"), this);
+    m_tabWidget->addWebAction(m_historyBack, QWebPage::Back);
+    m_historyBack->setShortcuts(QKeySequence::Back);
+    m_historyBack->setIconVisibleInMenu(false);
+
+    m_historyForward = new QAction(tr("Forward"), this);
+    m_tabWidget->addWebAction(m_historyForward, QWebPage::Forward);
+    m_historyForward->setShortcuts(QKeySequence::Forward);
+    m_historyForward->setIconVisibleInMenu(false);
+
+    QAction *m_historyHome = new QAction(tr("Home"), this);
+    connect(m_historyHome, SIGNAL(triggered()), this, SLOT(slotHome()));
+    m_historyHome->setShortcut(QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_H));
+
+    m_restoreLastSession = new QAction(tr("Restore Last Session"), this);
+    connect(m_restoreLastSession, SIGNAL(triggered()), BrowserApplication::instance(), SLOT(restoreLastSession()));
+    m_restoreLastSession->setEnabled(BrowserApplication::instance()->canRestoreSession());
+
+    historyActions.append(m_historyBack);
+    historyActions.append(m_historyForward);
+    historyActions.append(m_historyHome);
+    historyActions.append(m_tabWidget->recentlyClosedTabsAction());
+    historyActions.append(m_restoreLastSession);
+    historyMenu->setInitialActions(historyActions);
+
+    // Bookmarks
+    BookmarksMenu *bookmarksMenu = new BookmarksMenu(this);
+    connect(bookmarksMenu, SIGNAL(openUrl(const QUrl&)),
+            m_tabWidget, SLOT(loadUrlInCurrentTab(const QUrl&)));
+    connect(bookmarksMenu, SIGNAL(hovered(const QString&)),
+            this, SLOT(slotUpdateStatusbar(const QString&)));
+    bookmarksMenu->setTitle(tr("&Bookmarks"));
+    menuBar()->addMenu(bookmarksMenu);
+
+    QList<QAction*> bookmarksActions;
+
+    QAction *showAllBookmarksAction = new QAction(tr("Show All Bookmarks"), this);
+    connect(showAllBookmarksAction, SIGNAL(triggered()), this, SLOT(slotShowBookmarksDialog()));
+    m_addBookmark = new QAction(QIcon(QLatin1String(":addbookmark.png")), tr("Add Bookmark..."), this);
+    m_addBookmark->setIconVisibleInMenu(false);
+
+    connect(m_addBookmark, SIGNAL(triggered()), this, SLOT(slotAddBookmark()));
+    m_addBookmark->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_D));
+
+    bookmarksActions.append(showAllBookmarksAction);
+    bookmarksActions.append(m_addBookmark);
+    bookmarksMenu->setInitialActions(bookmarksActions);
+
+    // Window
+    m_windowMenu = menuBar()->addMenu(tr("&Window"));
+    connect(m_windowMenu, SIGNAL(aboutToShow()),
+            this, SLOT(slotAboutToShowWindowMenu()));
+    slotAboutToShowWindowMenu();
+
+    QMenu *toolsMenu = menuBar()->addMenu(tr("&Tools"));
+    toolsMenu->addAction(tr("Web &Search"), this, SLOT(slotWebSearch()), QKeySequence(tr("Ctrl+K", "Web Search")));
+#ifndef Q_CC_MINGW
+    a = toolsMenu->addAction(tr("Enable Web &Inspector"), this, SLOT(slotToggleInspector(bool)));
+    a->setCheckable(true);
+#endif
+
+    QMenu *helpMenu = menuBar()->addMenu(tr("&Help"));
+    helpMenu->addAction(tr("About &Qt"), qApp, SLOT(aboutQt()));
+    helpMenu->addAction(tr("About &Demo Browser"), this, SLOT(slotAboutApplication()));
+}
+
+void BrowserMainWindow::setupToolBar()
+{
+    setUnifiedTitleAndToolBarOnMac(true);
+    m_navigationBar = addToolBar(tr("Navigation"));
+    connect(m_navigationBar->toggleViewAction(), SIGNAL(toggled(bool)),
+            this, SLOT(updateToolbarActionText(bool)));
+
+    m_historyBack->setIcon(style()->standardIcon(QStyle::SP_ArrowBack, 0, this));
+    m_historyBackMenu = new QMenu(this);
+    m_historyBack->setMenu(m_historyBackMenu);
+    connect(m_historyBackMenu, SIGNAL(aboutToShow()),
+            this, SLOT(slotAboutToShowBackMenu()));
+    connect(m_historyBackMenu, SIGNAL(triggered(QAction *)),
+            this, SLOT(slotOpenActionUrl(QAction *)));
+    m_navigationBar->addAction(m_historyBack);
+
+    m_historyForward->setIcon(style()->standardIcon(QStyle::SP_ArrowForward, 0, this));
+    m_historyForwardMenu = new QMenu(this);
+    connect(m_historyForwardMenu, SIGNAL(aboutToShow()),
+            this, SLOT(slotAboutToShowForwardMenu()));
+    connect(m_historyForwardMenu, SIGNAL(triggered(QAction *)),
+            this, SLOT(slotOpenActionUrl(QAction *)));
+    m_historyForward->setMenu(m_historyForwardMenu);
+    m_navigationBar->addAction(m_historyForward);
+
+    m_stopReload = new QAction(this);
+    m_reloadIcon = style()->standardIcon(QStyle::SP_BrowserReload);
+    m_stopReload->setIcon(m_reloadIcon);
+
+    m_navigationBar->addAction(m_stopReload);
+
+    m_navigationBar->addWidget(m_tabWidget->lineEditStack());
+
+    m_toolbarSearch = new ToolbarSearch(m_navigationBar);
+    m_navigationBar->addWidget(m_toolbarSearch);
+    connect(m_toolbarSearch, SIGNAL(search(const QUrl&)), SLOT(loadUrl(const QUrl&)));
+
+    m_chaseWidget = new ChaseWidget(this);
+    m_navigationBar->addWidget(m_chaseWidget);
+}
+
+void BrowserMainWindow::slotShowBookmarksDialog()
+{
+    BookmarksDialog *dialog = new BookmarksDialog(this);
+    connect(dialog, SIGNAL(openUrl(const QUrl&)),
+            m_tabWidget, SLOT(loadUrlInCurrentTab(const QUrl&)));
+    dialog->show();
+}
+
+void BrowserMainWindow::slotAddBookmark()
+{
+    WebView *webView = currentTab();
+    QString url = webView->url().toString();
+    QString title = webView->title();
+    AddBookmarkDialog dialog(url, title);
+    dialog.exec();
+}
+
+void BrowserMainWindow::slotViewToolbar()
+{
+    if (m_navigationBar->isVisible()) {
+        updateToolbarActionText(false);
+        m_navigationBar->close();
+    } else {
+        updateToolbarActionText(true);
+        m_navigationBar->show();
+    }
+    m_autoSaver->changeOccurred();
+}
+
+void BrowserMainWindow::slotViewBookmarksBar()
+{
+    if (m_bookmarksToolbar->isVisible()) {
+        updateBookmarksToolbarActionText(false);
+        m_bookmarksToolbar->close();
+    } else {
+        updateBookmarksToolbarActionText(true);
+        m_bookmarksToolbar->show();
+    }
+    m_autoSaver->changeOccurred();
+}
+
+void BrowserMainWindow::updateStatusbarActionText(bool visible)
+{
+    m_viewStatusbar->setText(!visible ? tr("Show Status Bar") : tr("Hide Status Bar"));
+}
+
+void BrowserMainWindow::updateToolbarActionText(bool visible)
+{
+    m_viewToolbar->setText(!visible ? tr("Show Toolbar") : tr("Hide Toolbar"));
+}
+
+void BrowserMainWindow::updateBookmarksToolbarActionText(bool visible)
+{
+    m_viewBookmarkBar->setText(!visible ? tr("Show Bookmarks bar") : tr("Hide Bookmarks bar"));
+}
+
+void BrowserMainWindow::slotViewStatusbar()
+{
+    if (statusBar()->isVisible()) {
+        updateStatusbarActionText(false);
+        statusBar()->close();
+    } else {
+        updateStatusbarActionText(true);
+        statusBar()->show();
+    }
+    m_autoSaver->changeOccurred();
+}
+
+QUrl BrowserMainWindow::guessUrlFromString(const QString &string)
+{
+    QString urlStr = string.trimmed();
+    QRegExp test(QLatin1String("^[a-zA-Z]+\\:.*"));
+
+    // Check if it looks like a qualified URL. Try parsing it and see.
+    bool hasSchema = test.exactMatch(urlStr);
+    if (hasSchema) {
+        QUrl url = QUrl::fromEncoded(urlStr.toUtf8(), QUrl::TolerantMode);
+        if (url.isValid())
+            return url;
+    }
+
+    // Might be a file.
+    if (QFile::exists(urlStr)) {
+        QFileInfo info(urlStr);
+        return QUrl::fromLocalFile(info.absoluteFilePath());
+    }
+
+    // Might be a shorturl - try to detect the schema.
+    if (!hasSchema) {
+        int dotIndex = urlStr.indexOf(QLatin1Char('.'));
+        if (dotIndex != -1) {
+            QString prefix = urlStr.left(dotIndex).toLower();
+            QByteArray schema = (prefix == QLatin1String("ftp")) ? prefix.toLatin1() : "http";
+            QUrl url =
+                QUrl::fromEncoded(schema + "://" + urlStr.toUtf8(), QUrl::TolerantMode);
+            if (url.isValid())
+                return url;
+        }
+    }
+
+    // Fall back to QUrl's own tolerant parser.
+    QUrl url = QUrl::fromEncoded(string.toUtf8(), QUrl::TolerantMode);
+
+    // finally for cases where the user just types in a hostname add http
+    if (url.scheme().isEmpty())
+        url = QUrl::fromEncoded("http://" + string.toUtf8(), QUrl::TolerantMode);
+    return url;
+}
+
+void BrowserMainWindow::loadUrl(const QUrl &url)
+{
+    if (!currentTab() || !url.isValid())
+        return;
+
+    m_tabWidget->currentLineEdit()->setText(QString::fromUtf8(url.toEncoded()));
+    m_tabWidget->loadUrlInCurrentTab(url);
+}
+
+void BrowserMainWindow::slotDownloadManager()
+{
+    BrowserApplication::downloadManager()->show();
+}
+
+void BrowserMainWindow::slotSelectLineEdit()
+{
+    m_tabWidget->currentLineEdit()->selectAll();
+    m_tabWidget->currentLineEdit()->setFocus();
+}
+
+void BrowserMainWindow::slotFileSaveAs()
+{
+    BrowserApplication::downloadManager()->download(currentTab()->url(), true);
+}
+
+void BrowserMainWindow::slotPreferences()
+{
+    SettingsDialog *s = new SettingsDialog(this);
+    s->show();
+}
+
+void BrowserMainWindow::slotUpdateStatusbar(const QString &string)
+{
+    statusBar()->showMessage(string, 2000);
+}
+
+void BrowserMainWindow::slotUpdateWindowTitle(const QString &title)
+{
+    if (title.isEmpty()) {
+        setWindowTitle(tr("Qt Demo Browser"));
+    } else {
+#if defined(Q_WS_MAC)
+        setWindowTitle(title);
+#else
+        setWindowTitle(tr("%1 - Qt Demo Browser", "Page title and Browser name").arg(title));
+#endif
+    }
+}
+
+void BrowserMainWindow::slotAboutApplication()
+{
+    QMessageBox::about(this, tr("About"), tr(
+        "Version %1"
+        "<p>This demo demonstrates Qt's "
+        "webkit facilities in action, providing an example "
+        "browser for you to experiment with.<p>"
+        "<p>QtWebKit is based on the Open Source WebKit Project developed at <a href=\"http://webkit.org/\">http://webkit.org/</a>."
+        ).arg(QCoreApplication::applicationVersion()));
+}
+
+void BrowserMainWindow::slotFileNew()
+{
+    BrowserApplication::instance()->newMainWindow();
+    BrowserMainWindow *mw = BrowserApplication::instance()->mainWindow();
+    mw->slotHome();
+}
+
+void BrowserMainWindow::slotFileOpen()
+{
+    QString file = QFileDialog::getOpenFileName(this, tr("Open Web Resource"), QString(),
+            tr("Web Resources (*.html *.htm *.svg *.png *.gif *.svgz);;All files (*.*)"));
+
+    if (file.isEmpty())
+        return;
+
+    loadPage(file);
+}
+
+void BrowserMainWindow::slotFilePrintPreview()
+{
+#ifndef QT_NO_PRINTER
+    if (!currentTab())
+        return;
+    QPrintPreviewDialog *dialog = new QPrintPreviewDialog(this);
+    connect(dialog, SIGNAL(paintRequested(QPrinter *)),
+            currentTab(), SLOT(print(QPrinter *)));
+    dialog->exec();
+#endif
+}
+
+void BrowserMainWindow::slotFilePrint()
+{
+    if (!currentTab())
+        return;
+    printRequested(currentTab()->page()->mainFrame());
+}
+
+void BrowserMainWindow::printRequested(QWebFrame *frame)
+{
+#ifndef QT_NO_PRINTER
+    QPrinter printer;
+    QPrintDialog *dialog = new QPrintDialog(&printer, this);
+    dialog->setWindowTitle(tr("Print Document"));
+    if (dialog->exec() != QDialog::Accepted)
+        return;
+    frame->print(&printer);
+#endif
+}
+
+void BrowserMainWindow::slotPrivateBrowsing()
+{
+    QWebSettings *settings = QWebSettings::globalSettings();
+    bool pb = settings->testAttribute(QWebSettings::PrivateBrowsingEnabled);
+    if (!pb) {
+        QString title = tr("Are you sure you want to turn on private browsing?");
+        QString text = tr("<b>%1</b><br><br>When private browsing in turned on,"
+            " webpages are not added to the history,"
+            " items are automatically removed from the Downloads window," \
+            " new cookies are not stored, current cookies can't be accessed," \
+            " site icons wont be stored, session wont be saved, " \
+            " and searches are not addded to the pop-up menu in the Google search box." \
+            "  Until you close the window, you can still click the Back and Forward buttons" \
+            " to return to the webpages you have opened.").arg(title);
+
+        QMessageBox::StandardButton button = QMessageBox::question(this, QString(), text,
+                               QMessageBox::Ok | QMessageBox::Cancel,
+                               QMessageBox::Ok);
+        if (button == QMessageBox::Ok) {
+            settings->setAttribute(QWebSettings::PrivateBrowsingEnabled, true);
+        }
+    } else {
+        settings->setAttribute(QWebSettings::PrivateBrowsingEnabled, false);
+
+        QList<BrowserMainWindow*> windows = BrowserApplication::instance()->mainWindows();
+        for (int i = 0; i < windows.count(); ++i) {
+            BrowserMainWindow *window = windows.at(i);
+            window->m_lastSearch = QString::null;
+            window->tabWidget()->clear();
+        }
+    }
+}
+
+void BrowserMainWindow::closeEvent(QCloseEvent *event)
+{
+    if (m_tabWidget->count() > 1) {
+        int ret = QMessageBox::warning(this, QString(),
+                           tr("Are you sure you want to close the window?"
+                              "  There are %1 tab open").arg(m_tabWidget->count()),
+                           QMessageBox::Yes | QMessageBox::No,
+                           QMessageBox::No);
+        if (ret == QMessageBox::No) {
+            event->ignore();
+            return;
+        }
+    }
+    event->accept();
+    deleteLater();
+}
+
+void BrowserMainWindow::slotEditFind()
+{
+    if (!currentTab())
+        return;
+    bool ok;
+    QString search = QInputDialog::getText(this, tr("Find"),
+                                          tr("Text:"), QLineEdit::Normal,
+                                          m_lastSearch, &ok);
+    if (ok && !search.isEmpty()) {
+        m_lastSearch = search;
+        if (!currentTab()->findText(m_lastSearch))
+            slotUpdateStatusbar(tr("\"%1\" not found.").arg(m_lastSearch));
+    }
+}
+
+void BrowserMainWindow::slotEditFindNext()
+{
+    if (!currentTab() && !m_lastSearch.isEmpty())
+        return;
+    currentTab()->findText(m_lastSearch);
+}
+
+void BrowserMainWindow::slotEditFindPrevious()
+{
+    if (!currentTab() && !m_lastSearch.isEmpty())
+        return;
+    currentTab()->findText(m_lastSearch, QWebPage::FindBackward);
+}
+
+void BrowserMainWindow::slotViewZoomIn()
+{
+    if (!currentTab())
+        return;
+    currentTab()->setZoomFactor(currentTab()->zoomFactor() + 0.1);
+}
+
+void BrowserMainWindow::slotViewZoomOut()
+{
+    if (!currentTab())
+        return;
+    currentTab()->setZoomFactor(currentTab()->zoomFactor() - 0.1);
+}
+
+void BrowserMainWindow::slotViewResetZoom()
+{
+    if (!currentTab())
+        return;
+    currentTab()->setZoomFactor(1.0);
+}
+
+void BrowserMainWindow::slotViewZoomTextOnly(bool enable)
+{
+    if (!currentTab())
+        return;
+    currentTab()->page()->settings()->setAttribute(QWebSettings::ZoomTextOnly, enable);
+}
+
+void BrowserMainWindow::slotViewFullScreen(bool makeFullScreen)
+{
+    if (makeFullScreen) {
+        showFullScreen();
+    } else {
+        if (isMinimized())
+            showMinimized();
+        else if (isMaximized())
+            showMaximized();
+        else showNormal();
+    }
+}
+
+void BrowserMainWindow::slotViewPageSource()
+{
+    if (!currentTab())
+        return;
+
+    QString markup = currentTab()->page()->mainFrame()->toHtml();
+    QPlainTextEdit *view = new QPlainTextEdit(markup);
+    view->setWindowTitle(tr("Page Source of %1").arg(currentTab()->title()));
+    view->setMinimumWidth(640);
+    view->setAttribute(Qt::WA_DeleteOnClose);
+    view->show();
+}
+
+void BrowserMainWindow::slotHome()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("MainWindow"));
+    QString home = settings.value(QLatin1String("home"), QLatin1String("http://qtsoftware.com/")).toString();
+    loadPage(home);
+}
+
+void BrowserMainWindow::slotWebSearch()
+{
+    m_toolbarSearch->lineEdit()->selectAll();
+    m_toolbarSearch->lineEdit()->setFocus();
+}
+
+void BrowserMainWindow::slotToggleInspector(bool enable)
+{
+    QWebSettings::globalSettings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, enable);
+    if (enable) {
+        int result = QMessageBox::question(this, tr("Web Inspector"),
+                                           tr("The web inspector will only work correctly for pages that were loaded after enabling.\n"
+                                           "Do you want to reload all pages?"),
+                                           QMessageBox::Yes | QMessageBox::No);
+        if (result == QMessageBox::Yes) {
+            m_tabWidget->reloadAllTabs();
+        }
+    }
+}
+
+void BrowserMainWindow::slotSwapFocus()
+{
+    if (currentTab()->hasFocus())
+        m_tabWidget->currentLineEdit()->setFocus();
+    else
+        currentTab()->setFocus();
+}
+
+void BrowserMainWindow::loadPage(const QString &page)
+{
+    QUrl url = guessUrlFromString(page);
+    loadUrl(url);
+}
+
+TabWidget *BrowserMainWindow::tabWidget() const
+{
+    return m_tabWidget;
+}
+
+WebView *BrowserMainWindow::currentTab() const
+{
+    return m_tabWidget->currentWebView();
+}
+
+void BrowserMainWindow::slotLoadProgress(int progress)
+{
+    if (progress < 100 && progress > 0) {
+        m_chaseWidget->setAnimated(true);
+        disconnect(m_stopReload, SIGNAL(triggered()), m_reload, SLOT(trigger()));
+        if (m_stopIcon.isNull())
+            m_stopIcon = style()->standardIcon(QStyle::SP_BrowserStop);
+        m_stopReload->setIcon(m_stopIcon);
+        connect(m_stopReload, SIGNAL(triggered()), m_stop, SLOT(trigger()));
+        m_stopReload->setToolTip(tr("Stop loading the current page"));
+    } else {
+        m_chaseWidget->setAnimated(false);
+        disconnect(m_stopReload, SIGNAL(triggered()), m_stop, SLOT(trigger()));
+        m_stopReload->setIcon(m_reloadIcon);
+        connect(m_stopReload, SIGNAL(triggered()), m_reload, SLOT(trigger()));
+        m_stopReload->setToolTip(tr("Reload the current page"));
+    }
+}
+
+void BrowserMainWindow::slotAboutToShowBackMenu()
+{
+    m_historyBackMenu->clear();
+    if (!currentTab())
+        return;
+    QWebHistory *history = currentTab()->history();
+    int historyCount = history->count();
+    for (int i = history->backItems(historyCount).count() - 1; i >= 0; --i) {
+        QWebHistoryItem item = history->backItems(history->count()).at(i);
+        QAction *action = new QAction(this);
+        action->setData(-1*(historyCount-i-1));
+        QIcon icon = BrowserApplication::instance()->icon(item.url());
+        action->setIcon(icon);
+        action->setText(item.title());
+        m_historyBackMenu->addAction(action);
+    }
+}
+
+void BrowserMainWindow::slotAboutToShowForwardMenu()
+{
+    m_historyForwardMenu->clear();
+    if (!currentTab())
+        return;
+    QWebHistory *history = currentTab()->history();
+    int historyCount = history->count();
+    for (int i = 0; i < history->forwardItems(history->count()).count(); ++i) {
+        QWebHistoryItem item = history->forwardItems(historyCount).at(i);
+        QAction *action = new QAction(this);
+        action->setData(historyCount-i);
+        QIcon icon = BrowserApplication::instance()->icon(item.url());
+        action->setIcon(icon);
+        action->setText(item.title());
+        m_historyForwardMenu->addAction(action);
+    }
+}
+
+void BrowserMainWindow::slotAboutToShowWindowMenu()
+{
+    m_windowMenu->clear();
+    m_windowMenu->addAction(m_tabWidget->nextTabAction());
+    m_windowMenu->addAction(m_tabWidget->previousTabAction());
+    m_windowMenu->addSeparator();
+    m_windowMenu->addAction(tr("Downloads"), this, SLOT(slotDownloadManager()), QKeySequence(tr("Alt+Ctrl+L", "Download Manager")));
+
+    m_windowMenu->addSeparator();
+    QList<BrowserMainWindow*> windows = BrowserApplication::instance()->mainWindows();
+    for (int i = 0; i < windows.count(); ++i) {
+        BrowserMainWindow *window = windows.at(i);
+        QAction *action = m_windowMenu->addAction(window->windowTitle(), this, SLOT(slotShowWindow()));
+        action->setData(i);
+        action->setCheckable(true);
+        if (window == this)
+            action->setChecked(true);
+    }
+}
+
+void BrowserMainWindow::slotShowWindow()
+{
+    if (QAction *action = qobject_cast<QAction*>(sender())) {
+        QVariant v = action->data();
+        if (v.canConvert<int>()) {
+            int offset = qvariant_cast<int>(v);
+            QList<BrowserMainWindow*> windows = BrowserApplication::instance()->mainWindows();
+            windows.at(offset)->activateWindow();
+            windows.at(offset)->currentTab()->setFocus();
+        }
+    }
+}
+
+void BrowserMainWindow::slotOpenActionUrl(QAction *action)
+{
+    int offset = action->data().toInt();
+    QWebHistory *history = currentTab()->history();
+    if (offset < 0)
+        history->goToItem(history->backItems(-1*offset).first()); // back
+    else if (offset > 0)
+        history->goToItem(history->forwardItems(history->count() - offset + 1).back()); // forward
+ }
+
+void BrowserMainWindow::geometryChangeRequested(const QRect &geometry)
+{
+    setGeometry(geometry);
+}
+
diff --git a/examples/gestures/browser/browsermainwindow.h b/examples/gestures/browser/browsermainwindow.h
new file mode 100644
index 0000000..a8d08b0
--- /dev/null
+++ b/examples/gestures/browser/browsermainwindow.h
@@ -0,0 +1,169 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef BROWSERMAINWINDOW_H
+#define BROWSERMAINWINDOW_H
+
+#include <QtGui/QMainWindow>
+#include <QtGui/QIcon>
+#include <QtCore/QUrl>
+
+class AutoSaver;
+class BookmarksToolBar;
+class ChaseWidget;
+class QWebFrame;
+class TabWidget;
+class ToolbarSearch;
+class WebView;
+
+/*!
+    The MainWindow of the Browser Application.
+
+    Handles the tab widget and all the actions
+ */
+class BrowserMainWindow : public QMainWindow {
+    Q_OBJECT
+
+public:
+    BrowserMainWindow(QWidget *parent = 0, Qt::WindowFlags flags = 0);
+    ~BrowserMainWindow();
+    QSize sizeHint() const;
+
+public:
+    static QUrl guessUrlFromString(const QString &url);
+    TabWidget *tabWidget() const;
+    WebView *currentTab() const;
+    QByteArray saveState(bool withTabs = true) const;
+    bool restoreState(const QByteArray &state);
+
+public slots:
+    void loadPage(const QString &url);
+    void slotHome();
+
+protected:
+    void closeEvent(QCloseEvent *event);
+
+private slots:
+    void save();
+
+    void slotLoadProgress(int);
+    void slotUpdateStatusbar(const QString &string);
+    void slotUpdateWindowTitle(const QString &title = QString());
+
+    void loadUrl(const QUrl &url);
+    void slotPreferences();
+
+    void slotFileNew();
+    void slotFileOpen();
+    void slotFilePrintPreview();
+    void slotFilePrint();
+    void slotPrivateBrowsing();
+    void slotFileSaveAs();
+    void slotEditFind();
+    void slotEditFindNext();
+    void slotEditFindPrevious();
+    void slotShowBookmarksDialog();
+    void slotAddBookmark();
+    void slotViewZoomIn();
+    void slotViewZoomOut();
+    void slotViewResetZoom();
+    void slotViewZoomTextOnly(bool enable);
+    void slotViewToolbar();
+    void slotViewBookmarksBar();
+    void slotViewStatusbar();
+    void slotViewPageSource();
+    void slotViewFullScreen(bool enable);
+
+    void slotWebSearch();
+    void slotToggleInspector(bool enable);
+    void slotAboutApplication();
+    void slotDownloadManager();
+    void slotSelectLineEdit();
+
+    void slotAboutToShowBackMenu();
+    void slotAboutToShowForwardMenu();
+    void slotAboutToShowWindowMenu();
+    void slotOpenActionUrl(QAction *action);
+    void slotShowWindow();
+    void slotSwapFocus();
+
+    void printRequested(QWebFrame *frame);
+    void geometryChangeRequested(const QRect &geometry);
+    void updateToolbarActionText(bool visible);
+    void updateBookmarksToolbarActionText(bool visible);
+
+private:
+    void loadDefaultState();
+    void setupMenu();
+    void setupToolBar();
+    void updateStatusbarActionText(bool visible);
+
+private:
+    QToolBar *m_navigationBar;
+    ToolbarSearch *m_toolbarSearch;
+    BookmarksToolBar *m_bookmarksToolbar;
+    ChaseWidget *m_chaseWidget;
+    TabWidget *m_tabWidget;
+    AutoSaver *m_autoSaver;
+
+    QAction *m_historyBack;
+    QMenu *m_historyBackMenu;
+    QAction *m_historyForward;
+    QMenu *m_historyForwardMenu;
+    QMenu *m_windowMenu;
+
+    QAction *m_stop;
+    QAction *m_reload;
+    QAction *m_stopReload;
+    QAction *m_viewToolbar;
+    QAction *m_viewBookmarkBar;
+    QAction *m_viewStatusbar;
+    QAction *m_restoreLastSession;
+    QAction *m_addBookmark;
+
+    QIcon m_reloadIcon;
+    QIcon m_stopIcon;
+
+    QString m_lastSearch;
+};
+
+#endif // BROWSERMAINWINDOW_H
+
diff --git a/examples/gestures/browser/chasewidget.cpp b/examples/gestures/browser/chasewidget.cpp
new file mode 100644
index 0000000..c05bf30
--- /dev/null
+++ b/examples/gestures/browser/chasewidget.cpp
@@ -0,0 +1,142 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "chasewidget.h"
+
+#include <QtCore/QPoint>
+
+#include <QtGui/QApplication>
+#include <QtGui/QHideEvent>
+#include <QtGui/QPainter>
+#include <QtGui/QPaintEvent>
+#include <QtGui/QShowEvent>
+
+ChaseWidget::ChaseWidget(QWidget *parent, QPixmap pixmap, bool pixmapEnabled)
+    : QWidget(parent)
+    , m_segment(0)
+    , m_delay(100)
+    , m_step(40)
+    , m_timerId(-1)
+    , m_animated(false)
+    , m_pixmap(pixmap)
+    , m_pixmapEnabled(pixmapEnabled)
+{
+}
+
+void ChaseWidget::setAnimated(bool value)
+{
+    if (m_animated == value)
+        return;
+    m_animated = value;
+    if (m_timerId != -1) {
+        killTimer(m_timerId);
+        m_timerId = -1;
+    }
+    if (m_animated) {
+        m_segment = 0;
+        m_timerId = startTimer(m_delay);
+    }
+    update();
+}
+
+void ChaseWidget::paintEvent(QPaintEvent *event)
+{
+    Q_UNUSED(event);
+    QPainter p(this);
+    if (m_pixmapEnabled && !m_pixmap.isNull()) {
+        p.drawPixmap(0, 0, m_pixmap);
+        return;
+    }
+
+    const int extent = qMin(width() - 8, height() - 8);
+    const int displ = extent / 4;
+    const int ext = extent / 4 - 1;
+
+    p.setRenderHint(QPainter::Antialiasing, true);
+
+    if(m_animated)
+        p.setPen(Qt::gray);
+    else
+        p.setPen(QPen(palette().dark().color()));
+
+    p.translate(width() / 2, height() / 2); // center
+
+    for (int segment = 0; segment < segmentCount(); ++segment) {
+        p.rotate(QApplication::isRightToLeft() ? m_step : -m_step);
+        if(m_animated)
+            p.setBrush(colorForSegment(segment));
+        else
+            p.setBrush(palette().background());
+        p.drawEllipse(QRect(displ, -ext / 2, ext, ext));
+    }
+}
+
+QSize ChaseWidget::sizeHint() const
+{
+    return QSize(32, 32);
+}
+
+void ChaseWidget::timerEvent(QTimerEvent *event)
+{
+    if (event->timerId() == m_timerId) {
+        ++m_segment;
+        update();
+    }
+    QWidget::timerEvent(event);
+}
+
+QColor ChaseWidget::colorForSegment(int seg) const
+{
+    int index = ((seg + m_segment) % segmentCount());
+    int comp = qMax(0, 255 - (index * (255 / segmentCount())));
+    return QColor(comp, comp, comp, 255);
+}
+
+int ChaseWidget::segmentCount() const
+{
+    return 360 / m_step;
+}
+
+void ChaseWidget::setPixmapEnabled(bool enable)
+{
+    m_pixmapEnabled = enable;
+}
+
diff --git a/examples/gestures/browser/chasewidget.h b/examples/gestures/browser/chasewidget.h
new file mode 100644
index 0000000..257eb38
--- /dev/null
+++ b/examples/gestures/browser/chasewidget.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef CHASEWIDGET_H
+#define CHASEWIDGET_H
+
+#include <QtGui/QWidget>
+
+#include <QtCore/QSize>
+#include <QtGui/QColor>
+#include <QtGui/QPixmap>
+
+QT_BEGIN_NAMESPACE
+class QHideEvent;
+class QShowEvent;
+class QPaintEvent;
+class QTimerEvent;
+QT_END_NAMESPACE
+
+class ChaseWidget : public QWidget
+{
+    Q_OBJECT
+public:
+    ChaseWidget(QWidget *parent = 0, QPixmap pixmap = QPixmap(), bool pixmapEnabled = false);
+
+    void setAnimated(bool value);
+    void setPixmapEnabled(bool enable);
+    QSize sizeHint() const;
+
+protected:
+    void paintEvent(QPaintEvent *event);
+    void timerEvent(QTimerEvent *event);
+
+private:
+    int segmentCount() const;
+    QColor colorForSegment(int segment) const;
+
+    int m_segment;
+    int m_delay;
+    int m_step;
+    int m_timerId;
+    bool m_animated;
+    QPixmap m_pixmap;
+    bool m_pixmapEnabled;
+};
+
+#endif
diff --git a/examples/gestures/browser/cookiejar.cpp b/examples/gestures/browser/cookiejar.cpp
new file mode 100644
index 0000000..16aa5c6
--- /dev/null
+++ b/examples/gestures/browser/cookiejar.cpp
@@ -0,0 +1,733 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "cookiejar.h"
+
+#include "autosaver.h"
+
+#include <QtCore/QDateTime>
+#include <QtCore/QDir>
+#include <QtCore/QFile>
+#include <QtCore/QMetaEnum>
+#include <QtCore/QSettings>
+#include <QtCore/QUrl>
+
+#include <QtGui/QCompleter>
+#include <QtGui/QDesktopServices>
+#include <QtGui/QFont>
+#include <QtGui/QFontMetrics>
+#include <QtGui/QHeaderView>
+#include <QtGui/QKeyEvent>
+#include <QtGui/QSortFilterProxyModel>
+
+#include <QtWebKit/QWebSettings>
+
+#include <QtCore/QDebug>
+
+static const unsigned int JAR_VERSION = 23;
+
+QT_BEGIN_NAMESPACE
+QDataStream &operator<<(QDataStream &stream, const QList<QNetworkCookie> &list)
+{
+    stream << JAR_VERSION;
+    stream << quint32(list.size());
+    for (int i = 0; i < list.size(); ++i)
+        stream << list.at(i).toRawForm();
+    return stream;
+}
+
+QDataStream &operator>>(QDataStream &stream, QList<QNetworkCookie> &list)
+{
+    list.clear();
+
+    quint32 version;
+    stream >> version;
+
+    if (version != JAR_VERSION)
+        return stream;
+
+    quint32 count;
+    stream >> count;
+    for(quint32 i = 0; i < count; ++i)
+    {
+        QByteArray value;
+        stream >> value;
+        QList<QNetworkCookie> newCookies = QNetworkCookie::parseCookies(value);
+        if (newCookies.count() == 0 && value.length() != 0) {
+            qWarning() << "CookieJar: Unable to parse saved cookie:" << value;
+        }
+        for (int j = 0; j < newCookies.count(); ++j)
+            list.append(newCookies.at(j));
+        if (stream.atEnd())
+            break;
+    }
+    return stream;
+}
+QT_END_NAMESPACE
+
+CookieJar::CookieJar(QObject *parent)
+    : QNetworkCookieJar(parent)
+    , m_loaded(false)
+    , m_saveTimer(new AutoSaver(this))
+    , m_acceptCookies(AcceptOnlyFromSitesNavigatedTo)
+{
+}
+
+CookieJar::~CookieJar()
+{
+    if (m_keepCookies == KeepUntilExit)
+        clear();
+    m_saveTimer->saveIfNeccessary();
+}
+
+void CookieJar::clear()
+{
+    setAllCookies(QList<QNetworkCookie>());
+    m_saveTimer->changeOccurred();
+    emit cookiesChanged();
+}
+
+void CookieJar::load()
+{
+    if (m_loaded)
+        return;
+    // load cookies and exceptions
+    qRegisterMetaTypeStreamOperators<QList<QNetworkCookie> >("QList<QNetworkCookie>");
+    QSettings cookieSettings(QDesktopServices::storageLocation(QDesktopServices::DataLocation) + QLatin1String("/cookies.ini"), QSettings::IniFormat);
+    setAllCookies(qvariant_cast<QList<QNetworkCookie> >(cookieSettings.value(QLatin1String("cookies"))));
+    cookieSettings.beginGroup(QLatin1String("Exceptions"));
+    m_exceptions_block = cookieSettings.value(QLatin1String("block")).toStringList();
+    m_exceptions_allow = cookieSettings.value(QLatin1String("allow")).toStringList();
+    m_exceptions_allowForSession = cookieSettings.value(QLatin1String("allowForSession")).toStringList();
+    qSort(m_exceptions_block.begin(), m_exceptions_block.end());
+    qSort(m_exceptions_allow.begin(), m_exceptions_allow.end());
+    qSort(m_exceptions_allowForSession.begin(), m_exceptions_allowForSession.end());
+
+    loadSettings();
+}
+
+void CookieJar::loadSettings()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("cookies"));
+    QByteArray value = settings.value(QLatin1String("acceptCookies"),
+                        QLatin1String("AcceptOnlyFromSitesNavigatedTo")).toByteArray();
+    QMetaEnum acceptPolicyEnum = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("AcceptPolicy"));
+    m_acceptCookies = acceptPolicyEnum.keyToValue(value) == -1 ?
+                        AcceptOnlyFromSitesNavigatedTo :
+                        static_cast<AcceptPolicy>(acceptPolicyEnum.keyToValue(value));
+
+    value = settings.value(QLatin1String("keepCookiesUntil"), QLatin1String("KeepUntilExpire")).toByteArray();
+    QMetaEnum keepPolicyEnum = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("KeepPolicy"));
+    m_keepCookies = keepPolicyEnum.keyToValue(value) == -1 ?
+                        KeepUntilExpire :
+                        static_cast<KeepPolicy>(keepPolicyEnum.keyToValue(value));
+
+    if (m_keepCookies == KeepUntilExit)
+        setAllCookies(QList<QNetworkCookie>());
+
+    m_loaded = true;
+    emit cookiesChanged();
+}
+
+void CookieJar::save()
+{
+    if (!m_loaded)
+        return;
+    purgeOldCookies();
+    QString directory = QDesktopServices::storageLocation(QDesktopServices::DataLocation);
+    if (directory.isEmpty())
+        directory = QDir::homePath() + QLatin1String("/.") + QCoreApplication::applicationName();
+    if (!QFile::exists(directory)) {
+        QDir dir;
+        dir.mkpath(directory);
+    }
+    QSettings cookieSettings(directory + QLatin1String("/cookies.ini"), QSettings::IniFormat);
+    QList<QNetworkCookie> cookies = allCookies();
+    for (int i = cookies.count() - 1; i >= 0; --i) {
+        if (cookies.at(i).isSessionCookie())
+            cookies.removeAt(i);
+    }
+    cookieSettings.setValue(QLatin1String("cookies"), qVariantFromValue<QList<QNetworkCookie> >(cookies));
+    cookieSettings.beginGroup(QLatin1String("Exceptions"));
+    cookieSettings.setValue(QLatin1String("block"), m_exceptions_block);
+    cookieSettings.setValue(QLatin1String("allow"), m_exceptions_allow);
+    cookieSettings.setValue(QLatin1String("allowForSession"), m_exceptions_allowForSession);
+
+    // save cookie settings
+    QSettings settings;
+    settings.beginGroup(QLatin1String("cookies"));
+    QMetaEnum acceptPolicyEnum = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("AcceptPolicy"));
+    settings.setValue(QLatin1String("acceptCookies"), QLatin1String(acceptPolicyEnum.valueToKey(m_acceptCookies)));
+
+    QMetaEnum keepPolicyEnum = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("KeepPolicy"));
+    settings.setValue(QLatin1String("keepCookiesUntil"), QLatin1String(keepPolicyEnum.valueToKey(m_keepCookies)));
+}
+
+void CookieJar::purgeOldCookies()
+{
+    QList<QNetworkCookie> cookies = allCookies();
+    if (cookies.isEmpty())
+        return;
+    int oldCount = cookies.count();
+    QDateTime now = QDateTime::currentDateTime();
+    for (int i = cookies.count() - 1; i >= 0; --i) {
+        if (!cookies.at(i).isSessionCookie() && cookies.at(i).expirationDate() < now)
+            cookies.removeAt(i);
+    }
+    if (oldCount == cookies.count())
+        return;
+    setAllCookies(cookies);
+    emit cookiesChanged();
+}
+
+QList<QNetworkCookie> CookieJar::cookiesForUrl(const QUrl &url) const
+{
+    CookieJar *that = const_cast<CookieJar*>(this);
+    if (!m_loaded)
+        that->load();
+
+    QWebSettings *globalSettings = QWebSettings::globalSettings();
+    if (globalSettings->testAttribute(QWebSettings::PrivateBrowsingEnabled)) {
+        QList<QNetworkCookie> noCookies;
+        return noCookies;
+    }
+
+    return QNetworkCookieJar::cookiesForUrl(url);
+}
+
+bool CookieJar::setCookiesFromUrl(const QList<QNetworkCookie> &cookieList, const QUrl &url)
+{
+    if (!m_loaded)
+        load();
+
+    QWebSettings *globalSettings = QWebSettings::globalSettings();
+    if (globalSettings->testAttribute(QWebSettings::PrivateBrowsingEnabled))
+        return false;
+
+    QString host = url.host();
+    bool eBlock = qBinaryFind(m_exceptions_block.begin(), m_exceptions_block.end(), host) != m_exceptions_block.end();
+    bool eAllow = qBinaryFind(m_exceptions_allow.begin(), m_exceptions_allow.end(), host) != m_exceptions_allow.end();
+    bool eAllowSession = qBinaryFind(m_exceptions_allowForSession.begin(), m_exceptions_allowForSession.end(), host) != m_exceptions_allowForSession.end();
+
+    bool addedCookies = false;
+    // pass exceptions
+    bool acceptInitially = (m_acceptCookies != AcceptNever);
+    if ((acceptInitially && !eBlock)
+        || (!acceptInitially && (eAllow || eAllowSession))) {
+        // pass url domain == cookie domain
+        QDateTime soon = QDateTime::currentDateTime();
+        soon = soon.addDays(90);
+        foreach(QNetworkCookie cookie, cookieList) {
+            QList<QNetworkCookie> lst;
+            if (m_keepCookies == KeepUntilTimeLimit
+                && !cookie.isSessionCookie()
+                && cookie.expirationDate() > soon) {
+                    cookie.setExpirationDate(soon);
+            }
+            lst += cookie;
+            if (QNetworkCookieJar::setCookiesFromUrl(lst, url)) {
+                addedCookies = true;
+            } else {
+                // finally force it in if wanted
+                if (m_acceptCookies == AcceptAlways) {
+                    QList<QNetworkCookie> cookies = allCookies();
+                    cookies += cookie;
+                    setAllCookies(cookies);
+                    addedCookies = true;
+                }
+#if 0
+                else
+                    qWarning() << "setCookiesFromUrl failed" << url << cookieList.value(0).toRawForm();
+#endif
+            }
+        }
+    }
+
+    if (addedCookies) {
+        m_saveTimer->changeOccurred();
+        emit cookiesChanged();
+    }
+    return addedCookies;
+}
+
+CookieJar::AcceptPolicy CookieJar::acceptPolicy() const
+{
+    if (!m_loaded)
+        (const_cast<CookieJar*>(this))->load();
+    return m_acceptCookies;
+}
+
+void CookieJar::setAcceptPolicy(AcceptPolicy policy)
+{
+    if (!m_loaded)
+        load();
+    if (policy == m_acceptCookies)
+        return;
+    m_acceptCookies = policy;
+    m_saveTimer->changeOccurred();
+}
+
+CookieJar::KeepPolicy CookieJar::keepPolicy() const
+{
+    if (!m_loaded)
+        (const_cast<CookieJar*>(this))->load();
+    return m_keepCookies;
+}
+
+void CookieJar::setKeepPolicy(KeepPolicy policy)
+{
+    if (!m_loaded)
+        load();
+    if (policy == m_keepCookies)
+        return;
+    m_keepCookies = policy;
+    m_saveTimer->changeOccurred();
+}
+
+QStringList CookieJar::blockedCookies() const
+{
+    if (!m_loaded)
+        (const_cast<CookieJar*>(this))->load();
+    return m_exceptions_block;
+}
+
+QStringList CookieJar::allowedCookies() const
+{
+    if (!m_loaded)
+        (const_cast<CookieJar*>(this))->load();
+    return m_exceptions_allow;
+}
+
+QStringList CookieJar::allowForSessionCookies() const
+{
+    if (!m_loaded)
+        (const_cast<CookieJar*>(this))->load();
+    return m_exceptions_allowForSession;
+}
+
+void CookieJar::setBlockedCookies(const QStringList &list)
+{
+    if (!m_loaded)
+        load();
+    m_exceptions_block = list;
+    qSort(m_exceptions_block.begin(), m_exceptions_block.end());
+    m_saveTimer->changeOccurred();
+}
+
+void CookieJar::setAllowedCookies(const QStringList &list)
+{
+    if (!m_loaded)
+        load();
+    m_exceptions_allow = list;
+    qSort(m_exceptions_allow.begin(), m_exceptions_allow.end());
+    m_saveTimer->changeOccurred();
+}
+
+void CookieJar::setAllowForSessionCookies(const QStringList &list)
+{
+    if (!m_loaded)
+        load();
+    m_exceptions_allowForSession = list;
+    qSort(m_exceptions_allowForSession.begin(), m_exceptions_allowForSession.end());
+    m_saveTimer->changeOccurred();
+}
+
+CookieModel::CookieModel(CookieJar *cookieJar, QObject *parent)
+    : QAbstractTableModel(parent)
+    , m_cookieJar(cookieJar)
+{
+    connect(m_cookieJar, SIGNAL(cookiesChanged()), this, SLOT(cookiesChanged()));
+    m_cookieJar->load();
+}
+
+QVariant CookieModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    if (role == Qt::SizeHintRole) {
+        QFont font;
+        font.setPointSize(10);
+        QFontMetrics fm(font);
+        int height = fm.height() + fm.height()/3;
+        int width = fm.width(headerData(section, orientation, Qt::DisplayRole).toString());
+        return QSize(width, height);
+    }
+
+    if (orientation == Qt::Horizontal) {
+        if (role != Qt::DisplayRole)
+            return QVariant();
+
+        switch (section) {
+            case 0:
+                return tr("Website");
+            case 1:
+                return tr("Name");
+            case 2:
+                return tr("Path");
+            case 3:
+                return tr("Secure");
+            case 4:
+                return tr("Expires");
+            case 5:
+                return tr("Contents");
+            default:
+                return QVariant();
+        }
+    }
+    return QAbstractTableModel::headerData(section, orientation, role);
+}
+
+QVariant CookieModel::data(const QModelIndex &index, int role) const
+{
+    QList<QNetworkCookie> lst;
+    if (m_cookieJar)
+        lst = m_cookieJar->allCookies();
+    if (index.row() < 0 || index.row() >= lst.size())
+        return QVariant();
+
+    switch (role) {
+    case Qt::DisplayRole:
+    case Qt::EditRole: {
+        QNetworkCookie cookie = lst.at(index.row());
+        switch (index.column()) {
+            case 0:
+                return cookie.domain();
+            case 1:
+                return cookie.name();
+            case 2:
+                return cookie.path();
+            case 3:
+                return cookie.isSecure();
+            case 4:
+                return cookie.expirationDate();
+            case 5:
+                return cookie.value();
+        }
+        }
+    case Qt::FontRole:{
+        QFont font;
+        font.setPointSize(10);
+        return font;
+        }
+    }
+
+    return QVariant();
+}
+
+int CookieModel::columnCount(const QModelIndex &parent) const
+{
+    return (parent.isValid()) ? 0 : 6;
+}
+
+int CookieModel::rowCount(const QModelIndex &parent) const
+{
+    return (parent.isValid() || !m_cookieJar) ? 0 : m_cookieJar->allCookies().count();
+}
+
+bool CookieModel::removeRows(int row, int count, const QModelIndex &parent)
+{
+    if (parent.isValid() || !m_cookieJar)
+        return false;
+    int lastRow = row + count - 1;
+    beginRemoveRows(parent, row, lastRow);
+    QList<QNetworkCookie> lst = m_cookieJar->allCookies();
+    for (int i = lastRow; i >= row; --i) {
+        lst.removeAt(i);
+    }
+    m_cookieJar->setAllCookies(lst);
+    endRemoveRows();
+    return true;
+}
+
+void CookieModel::cookiesChanged()
+{
+    reset();
+}
+
+CookiesDialog::CookiesDialog(CookieJar *cookieJar, QWidget *parent) : QDialog(parent)
+{
+    setupUi(this);
+    setWindowFlags(Qt::Sheet);
+    CookieModel *model = new CookieModel(cookieJar, this);
+    m_proxyModel = new QSortFilterProxyModel(this);
+    connect(search, SIGNAL(textChanged(QString)),
+            m_proxyModel, SLOT(setFilterFixedString(QString)));
+    connect(removeButton, SIGNAL(clicked()), cookiesTable, SLOT(removeOne()));
+    connect(removeAllButton, SIGNAL(clicked()), cookiesTable, SLOT(removeAll()));
+    m_proxyModel->setSourceModel(model);
+    cookiesTable->verticalHeader()->hide();
+    cookiesTable->setSelectionBehavior(QAbstractItemView::SelectRows);
+    cookiesTable->setModel(m_proxyModel);
+    cookiesTable->setAlternatingRowColors(true);
+    cookiesTable->setTextElideMode(Qt::ElideMiddle);
+    cookiesTable->setShowGrid(false);
+    cookiesTable->setSortingEnabled(true);
+    QFont f = font();
+    f.setPointSize(10);
+    QFontMetrics fm(f);
+    int height = fm.height() + fm.height()/3;
+    cookiesTable->verticalHeader()->setDefaultSectionSize(height);
+    cookiesTable->verticalHeader()->setMinimumSectionSize(-1);
+    for (int i = 0; i < model->columnCount(); ++i){
+        int header = cookiesTable->horizontalHeader()->sectionSizeHint(i);
+        switch (i) {
+        case 0:
+            header = fm.width(QLatin1String("averagehost.domain.com"));
+            break;
+        case 1:
+            header = fm.width(QLatin1String("_session_id"));
+            break;
+        case 4:
+            header = fm.width(QDateTime::currentDateTime().toString(Qt::LocalDate));
+            break;
+        }
+        int buffer = fm.width(QLatin1String("xx"));
+        header += buffer;
+        cookiesTable->horizontalHeader()->resizeSection(i, header);
+    }
+    cookiesTable->horizontalHeader()->setStretchLastSection(true);
+}
+
+
+
+CookieExceptionsModel::CookieExceptionsModel(CookieJar *cookiejar, QObject *parent)
+    : QAbstractTableModel(parent)
+    , m_cookieJar(cookiejar)
+{
+    m_allowedCookies = m_cookieJar->allowedCookies();
+    m_blockedCookies = m_cookieJar->blockedCookies();
+    m_sessionCookies = m_cookieJar->allowForSessionCookies();
+}
+
+QVariant CookieExceptionsModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    if (role == Qt::SizeHintRole) {
+        QFont font;
+        font.setPointSize(10);
+        QFontMetrics fm(font);
+        int height = fm.height() + fm.height()/3;
+        int width = fm.width(headerData(section, orientation, Qt::DisplayRole).toString());
+        return QSize(width, height);
+    }
+
+    if (orientation == Qt::Horizontal
+        && role == Qt::DisplayRole) {
+        switch (section) {
+            case 0:
+                return tr("Website");
+            case 1:
+                return tr("Status");
+        }
+    }
+    return QAbstractTableModel::headerData(section, orientation, role);
+}
+
+QVariant CookieExceptionsModel::data(const QModelIndex &index, int role) const
+{
+    if (index.row() < 0 || index.row() >= rowCount())
+        return QVariant();
+
+    switch (role) {
+    case Qt::DisplayRole:
+    case Qt::EditRole: {
+        int row = index.row();
+        if (row < m_allowedCookies.count()) {
+            switch (index.column()) {
+                case 0:
+                    return m_allowedCookies.at(row);
+                case 1:
+                    return tr("Allow");
+            }
+        }
+        row = row - m_allowedCookies.count();
+        if (row < m_blockedCookies.count()) {
+            switch (index.column()) {
+                case 0:
+                    return m_blockedCookies.at(row);
+                case 1:
+                    return tr("Block");
+            }
+        }
+        row = row - m_blockedCookies.count();
+        if (row < m_sessionCookies.count()) {
+            switch (index.column()) {
+                case 0:
+                    return m_sessionCookies.at(row);
+                case 1:
+                    return tr("Allow For Session");
+            }
+        }
+        }
+    case Qt::FontRole:{
+        QFont font;
+        font.setPointSize(10);
+        return font;
+        }
+    }
+    return QVariant();
+}
+
+int CookieExceptionsModel::columnCount(const QModelIndex &parent) const
+{
+    return (parent.isValid()) ? 0 : 2;
+}
+
+int CookieExceptionsModel::rowCount(const QModelIndex &parent) const
+{
+    return (parent.isValid() || !m_cookieJar) ? 0 : m_allowedCookies.count() + m_blockedCookies.count() + m_sessionCookies.count();
+}
+
+bool CookieExceptionsModel::removeRows(int row, int count, const QModelIndex &parent)
+{
+    if (parent.isValid() || !m_cookieJar)
+        return false;
+
+    int lastRow = row + count - 1;
+    beginRemoveRows(parent, row, lastRow);
+    for (int i = lastRow; i >= row; --i) {
+        if (i < m_allowedCookies.count()) {
+            m_allowedCookies.removeAt(row);
+            continue;
+        }
+        i = i - m_allowedCookies.count();
+        if (i < m_blockedCookies.count()) {
+            m_blockedCookies.removeAt(row);
+            continue;
+        }
+        i = i - m_blockedCookies.count();
+        if (i < m_sessionCookies.count()) {
+            m_sessionCookies.removeAt(row);
+            continue;
+        }
+    }
+    m_cookieJar->setAllowedCookies(m_allowedCookies);
+    m_cookieJar->setBlockedCookies(m_blockedCookies);
+    m_cookieJar->setAllowForSessionCookies(m_sessionCookies);
+    endRemoveRows();
+    return true;
+}
+
+CookiesExceptionsDialog::CookiesExceptionsDialog(CookieJar *cookieJar, QWidget *parent)
+    : QDialog(parent)
+    , m_cookieJar(cookieJar)
+{
+    setupUi(this);
+    setWindowFlags(Qt::Sheet);
+    connect(removeButton, SIGNAL(clicked()), exceptionTable, SLOT(removeOne()));
+    connect(removeAllButton, SIGNAL(clicked()), exceptionTable, SLOT(removeAll()));
+    exceptionTable->verticalHeader()->hide();
+    exceptionTable->setSelectionBehavior(QAbstractItemView::SelectRows);
+    exceptionTable->setAlternatingRowColors(true);
+    exceptionTable->setTextElideMode(Qt::ElideMiddle);
+    exceptionTable->setShowGrid(false);
+    exceptionTable->setSortingEnabled(true);
+    m_exceptionsModel = new CookieExceptionsModel(cookieJar, this);
+    m_proxyModel = new QSortFilterProxyModel(this);
+    m_proxyModel->setSourceModel(m_exceptionsModel);
+    connect(search, SIGNAL(textChanged(QString)),
+            m_proxyModel, SLOT(setFilterFixedString(QString)));
+    exceptionTable->setModel(m_proxyModel);
+
+    CookieModel *cookieModel = new CookieModel(cookieJar, this);
+    domainLineEdit->setCompleter(new QCompleter(cookieModel, domainLineEdit));
+
+    connect(domainLineEdit, SIGNAL(textChanged(const QString &)),
+            this, SLOT(textChanged(const QString &)));
+    connect(blockButton, SIGNAL(clicked()), this, SLOT(block()));
+    connect(allowButton, SIGNAL(clicked()), this, SLOT(allow()));
+    connect(allowForSessionButton, SIGNAL(clicked()), this, SLOT(allowForSession()));
+
+    QFont f = font();
+    f.setPointSize(10);
+    QFontMetrics fm(f);
+    int height = fm.height() + fm.height()/3;
+    exceptionTable->verticalHeader()->setDefaultSectionSize(height);
+    exceptionTable->verticalHeader()->setMinimumSectionSize(-1);
+    for (int i = 0; i < m_exceptionsModel->columnCount(); ++i){
+        int header = exceptionTable->horizontalHeader()->sectionSizeHint(i);
+        switch (i) {
+        case 0:
+            header = fm.width(QLatin1String("averagebiglonghost.domain.com"));
+            break;
+        case 1:
+            header = fm.width(QLatin1String("Allow For Session"));
+            break;
+        }
+        int buffer = fm.width(QLatin1String("xx"));
+        header += buffer;
+        exceptionTable->horizontalHeader()->resizeSection(i, header);
+    }
+}
+
+void CookiesExceptionsDialog::textChanged(const QString &text)
+{
+    bool enabled = !text.isEmpty();
+    blockButton->setEnabled(enabled);
+    allowButton->setEnabled(enabled);
+    allowForSessionButton->setEnabled(enabled);
+}
+
+void CookiesExceptionsDialog::block()
+{
+    if (domainLineEdit->text().isEmpty())
+        return;
+    m_exceptionsModel->m_blockedCookies.append(domainLineEdit->text());
+    m_cookieJar->setBlockedCookies(m_exceptionsModel->m_blockedCookies);
+    m_exceptionsModel->reset();
+}
+
+void CookiesExceptionsDialog::allow()
+{
+    if (domainLineEdit->text().isEmpty())
+        return;
+    m_exceptionsModel->m_allowedCookies.append(domainLineEdit->text());
+    m_cookieJar->setAllowedCookies(m_exceptionsModel->m_allowedCookies);
+    m_exceptionsModel->reset();
+}
+
+void CookiesExceptionsDialog::allowForSession()
+{
+    if (domainLineEdit->text().isEmpty())
+        return;
+    m_exceptionsModel->m_sessionCookies.append(domainLineEdit->text());
+    m_cookieJar->setAllowForSessionCookies(m_exceptionsModel->m_sessionCookies);
+    m_exceptionsModel->reset();
+}
+
diff --git a/examples/gestures/browser/cookiejar.h b/examples/gestures/browser/cookiejar.h
new file mode 100644
index 0000000..2d53627
--- /dev/null
+++ b/examples/gestures/browser/cookiejar.h
@@ -0,0 +1,204 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef COOKIEJAR_H
+#define COOKIEJAR_H
+
+#include <QtNetwork/QNetworkCookieJar>
+
+#include <QtCore/QAbstractItemModel>
+#include <QtCore/QStringList>
+
+#include <QtGui/QDialog>
+#include <QtGui/QTableView>
+
+QT_BEGIN_NAMESPACE
+class QSortFilterProxyModel;
+class QKeyEvent;
+QT_END_NAMESPACE
+
+class AutoSaver;
+
+class CookieJar : public QNetworkCookieJar
+{
+    friend class CookieModel;
+    Q_OBJECT
+    Q_PROPERTY(AcceptPolicy acceptPolicy READ acceptPolicy WRITE setAcceptPolicy)
+    Q_PROPERTY(KeepPolicy keepPolicy READ keepPolicy WRITE setKeepPolicy)
+    Q_PROPERTY(QStringList blockedCookies READ blockedCookies WRITE setBlockedCookies)
+    Q_PROPERTY(QStringList allowedCookies READ allowedCookies WRITE setAllowedCookies)
+    Q_PROPERTY(QStringList allowForSessionCookies READ allowForSessionCookies WRITE setAllowForSessionCookies)
+    Q_ENUMS(KeepPolicy)
+    Q_ENUMS(AcceptPolicy)
+
+signals:
+    void cookiesChanged();
+
+public:
+    enum AcceptPolicy {
+        AcceptAlways,
+        AcceptNever,
+        AcceptOnlyFromSitesNavigatedTo
+    };
+
+    enum KeepPolicy {
+        KeepUntilExpire,
+        KeepUntilExit,
+        KeepUntilTimeLimit
+    };
+
+    CookieJar(QObject *parent = 0);
+    ~CookieJar();
+
+    QList<QNetworkCookie> cookiesForUrl(const QUrl &url) const;
+    bool setCookiesFromUrl(const QList<QNetworkCookie> &cookieList, const QUrl &url);
+
+    AcceptPolicy acceptPolicy() const;
+    void setAcceptPolicy(AcceptPolicy policy);
+
+    KeepPolicy keepPolicy() const;
+    void setKeepPolicy(KeepPolicy policy);
+
+    QStringList blockedCookies() const;
+    QStringList allowedCookies() const;
+    QStringList allowForSessionCookies() const;
+
+    void setBlockedCookies(const QStringList &list);
+    void setAllowedCookies(const QStringList &list);
+    void setAllowForSessionCookies(const QStringList &list);
+
+public slots:
+    void clear();
+    void loadSettings();
+
+private slots:
+    void save();
+
+private:
+    void purgeOldCookies();
+    void load();
+    bool m_loaded;
+    AutoSaver *m_saveTimer;
+
+    AcceptPolicy m_acceptCookies;
+    KeepPolicy m_keepCookies;
+
+    QStringList m_exceptions_block;
+    QStringList m_exceptions_allow;
+    QStringList m_exceptions_allowForSession;
+};
+
+class CookieModel : public QAbstractTableModel
+{
+    Q_OBJECT
+
+public:
+    CookieModel(CookieJar *jar, QObject *parent = 0);
+    QVariant headerData(int section, Qt::Orientation orientation, int role) const;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
+
+private slots:
+    void cookiesChanged();
+
+private:
+    CookieJar *m_cookieJar;
+};
+
+#include "ui_cookies.h"
+#include "ui_cookiesexceptions.h"
+
+class CookiesDialog : public QDialog, public Ui_CookiesDialog
+{
+    Q_OBJECT
+
+public:
+    CookiesDialog(CookieJar *cookieJar, QWidget *parent = 0);
+
+private:
+    QSortFilterProxyModel *m_proxyModel;
+};
+
+class CookieExceptionsModel : public QAbstractTableModel
+{
+    Q_OBJECT
+    friend class CookiesExceptionsDialog;
+
+public:
+    CookieExceptionsModel(CookieJar *cookieJar, QObject *parent = 0);
+    QVariant headerData(int section, Qt::Orientation orientation, int role) const;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
+
+private:
+    CookieJar *m_cookieJar;
+
+    // Domains we allow, Domains we block, Domains we allow for this session
+    QStringList m_allowedCookies;
+    QStringList m_blockedCookies;
+    QStringList m_sessionCookies;
+};
+
+class CookiesExceptionsDialog : public QDialog, public Ui_CookiesExceptionsDialog
+{
+    Q_OBJECT
+
+public:
+    CookiesExceptionsDialog(CookieJar *cookieJar, QWidget *parent = 0);
+
+private slots:
+    void block();
+    void allow();
+    void allowForSession();
+    void textChanged(const QString &text);
+
+private:
+    CookieExceptionsModel *m_exceptionsModel;
+    QSortFilterProxyModel *m_proxyModel;
+    CookieJar *m_cookieJar;
+};
+
+#endif // COOKIEJAR_H
+
diff --git a/examples/gestures/browser/cookies.ui b/examples/gestures/browser/cookies.ui
new file mode 100644
index 0000000..c4bccc5
--- /dev/null
+++ b/examples/gestures/browser/cookies.ui
@@ -0,0 +1,106 @@
+<ui version="4.0" >
+ <class>CookiesDialog</class>
+ <widget class="QDialog" name="CookiesDialog" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>550</width>
+    <height>370</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Cookies</string>
+  </property>
+  <layout class="QGridLayout" >
+   <item row="0" column="0" >
+    <spacer>
+     <property name="orientation" >
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="sizeHint" stdset="0" >
+      <size>
+       <width>252</width>
+       <height>20</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="0" column="1" >
+    <widget class="SearchLineEdit" name="search" />
+   </item>
+   <item row="1" column="0" colspan="2" >
+    <widget class="EditTableView" name="cookiesTable" />
+   </item>
+   <item row="2" column="0" colspan="2" >
+    <layout class="QHBoxLayout" >
+     <item>
+      <widget class="QPushButton" name="removeButton" >
+       <property name="text" >
+        <string>&amp;Remove</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="removeAllButton" >
+       <property name="text" >
+        <string>Remove &amp;All Cookies</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer>
+       <property name="orientation" >
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0" >
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QDialogButtonBox" name="buttonBox" >
+       <property name="standardButtons" >
+        <set>QDialogButtonBox::Ok</set>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>SearchLineEdit</class>
+   <extends>QLineEdit</extends>
+   <header>searchlineedit.h</header>
+  </customwidget>
+  <customwidget>
+   <class>EditTableView</class>
+   <extends>QTableView</extends>
+   <header>edittableview.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>CookiesDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel" >
+     <x>472</x>
+     <y>329</y>
+    </hint>
+    <hint type="destinationlabel" >
+     <x>461</x>
+     <y>356</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/examples/gestures/browser/cookiesexceptions.ui b/examples/gestures/browser/cookiesexceptions.ui
new file mode 100644
index 0000000..3d9ef62
--- /dev/null
+++ b/examples/gestures/browser/cookiesexceptions.ui
@@ -0,0 +1,184 @@
+<ui version="4.0" >
+ <class>CookiesExceptionsDialog</class>
+ <widget class="QDialog" name="CookiesExceptionsDialog" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>466</width>
+    <height>446</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Cookie Exceptions</string>
+  </property>
+  <layout class="QVBoxLayout" >
+   <item>
+    <widget class="QGroupBox" name="newExceptionGroupBox" >
+     <property name="title" >
+      <string>New Exception</string>
+     </property>
+     <layout class="QGridLayout" >
+      <item row="0" column="0" >
+       <layout class="QHBoxLayout" >
+        <item>
+         <widget class="QLabel" name="label" >
+          <property name="text" >
+           <string>Domain:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLineEdit" name="domainLineEdit" />
+        </item>
+       </layout>
+      </item>
+      <item row="1" column="0" >
+       <layout class="QHBoxLayout" >
+        <item>
+         <spacer>
+          <property name="orientation" >
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0" >
+           <size>
+            <width>81</width>
+            <height>25</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+        <item>
+         <widget class="QPushButton" name="blockButton" >
+          <property name="enabled" >
+           <bool>false</bool>
+          </property>
+          <property name="text" >
+           <string>Block</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="allowForSessionButton" >
+          <property name="enabled" >
+           <bool>false</bool>
+          </property>
+          <property name="text" >
+           <string>Allow For Session</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="allowButton" >
+          <property name="enabled" >
+           <bool>false</bool>
+          </property>
+          <property name="text" >
+           <string>Allow</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="ExceptionsGroupBox" >
+     <property name="title" >
+      <string>Exceptions</string>
+     </property>
+     <layout class="QGridLayout" >
+      <item row="0" column="0" colspan="3" >
+       <spacer>
+        <property name="orientation" >
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeHint" stdset="0" >
+         <size>
+          <width>252</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item row="0" column="3" >
+       <widget class="SearchLineEdit" name="search" />
+      </item>
+      <item row="1" column="0" colspan="4" >
+       <widget class="EditTableView" name="exceptionTable" />
+      </item>
+      <item row="2" column="0" >
+       <widget class="QPushButton" name="removeButton" >
+        <property name="text" >
+         <string>&amp;Remove</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1" >
+       <widget class="QPushButton" name="removeAllButton" >
+        <property name="text" >
+         <string>Remove &amp;All</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="2" colspan="2" >
+       <spacer>
+        <property name="orientation" >
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeHint" stdset="0" >
+         <size>
+          <width>40</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox" >
+     <property name="orientation" >
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons" >
+      <set>QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>SearchLineEdit</class>
+   <extends>QLineEdit</extends>
+   <header>searchlineedit.h</header>
+  </customwidget>
+  <customwidget>
+   <class>EditTableView</class>
+   <extends>QTableView</extends>
+   <header>edittableview.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>CookiesExceptionsDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel" >
+     <x>381</x>
+     <y>428</y>
+    </hint>
+    <hint type="destinationlabel" >
+     <x>336</x>
+     <y>443</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/examples/gestures/browser/downloaditem.ui b/examples/gestures/browser/downloaditem.ui
new file mode 100644
index 0000000..4a0a0fd
--- /dev/null
+++ b/examples/gestures/browser/downloaditem.ui
@@ -0,0 +1,134 @@
+<ui version="4.0" >
+ <class>DownloadItem</class>
+ <widget class="QWidget" name="DownloadItem" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>423</width>
+    <height>110</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Form</string>
+  </property>
+  <layout class="QHBoxLayout" name="horizontalLayout" >
+   <property name="margin" >
+    <number>0</number>
+   </property>
+   <item>
+    <widget class="QLabel" name="fileIcon" >
+     <property name="sizePolicy" >
+      <sizepolicy vsizetype="Minimum" hsizetype="Minimum" >
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="text" >
+      <string>Ico</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QVBoxLayout" name="verticalLayout_2" >
+     <item>
+      <widget class="SqueezeLabel" native="1" name="fileNameLabel" >
+       <property name="sizePolicy" >
+        <sizepolicy vsizetype="Preferred" hsizetype="Expanding" >
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text" stdset="0" >
+        <string>Filename</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QProgressBar" name="progressBar" >
+       <property name="value" >
+        <number>0</number>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="SqueezeLabel" native="1" name="downloadInfoLabel" >
+       <property name="sizePolicy" >
+        <sizepolicy vsizetype="Preferred" hsizetype="Minimum" >
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text" stdset="0" >
+        <string/>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <layout class="QVBoxLayout" name="verticalLayout" >
+     <item>
+      <spacer name="verticalSpacer" >
+       <property name="orientation" >
+        <enum>Qt::Vertical</enum>
+       </property>
+       <property name="sizeHint" stdset="0" >
+        <size>
+         <width>17</width>
+         <height>1</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QPushButton" name="tryAgainButton" >
+       <property name="enabled" >
+        <bool>false</bool>
+       </property>
+       <property name="text" >
+        <string>Try Again</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="stopButton" >
+       <property name="text" >
+        <string>Stop</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="openButton" >
+       <property name="text" >
+        <string>Open</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="verticalSpacer_2" >
+       <property name="orientation" >
+        <enum>Qt::Vertical</enum>
+       </property>
+       <property name="sizeHint" stdset="0" >
+        <size>
+         <width>17</width>
+         <height>5</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>SqueezeLabel</class>
+   <extends>QWidget</extends>
+   <header>squeezelabel.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/examples/gestures/browser/downloadmanager.cpp b/examples/gestures/browser/downloadmanager.cpp
new file mode 100644
index 0000000..1e327c7
--- /dev/null
+++ b/examples/gestures/browser/downloadmanager.cpp
@@ -0,0 +1,579 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "downloadmanager.h"
+
+#include "autosaver.h"
+#include "browserapplication.h"
+#include "networkaccessmanager.h"
+
+#include <math.h>
+
+#include <QtCore/QMetaEnum>
+#include <QtCore/QSettings>
+
+#include <QtGui/QDesktopServices>
+#include <QtGui/QFileDialog>
+#include <QtGui/QHeaderView>
+#include <QtGui/QFileIconProvider>
+
+#include <QtCore/QDebug>
+
+#include <QtWebKit/QWebSettings>
+
+/*!
+    DownloadItem is a widget that is displayed in the download manager list.
+    It moves the data from the QNetworkReply into the QFile as well
+    as update the information/progressbar and report errors.
+ */
+DownloadItem::DownloadItem(QNetworkReply *reply, bool requestFileName, QWidget *parent)
+    : QWidget(parent)
+    , m_reply(reply)
+    , m_requestFileName(requestFileName)
+    , m_bytesReceived(0)
+{
+    setupUi(this);
+    QPalette p = downloadInfoLabel->palette();
+    p.setColor(QPalette::Text, Qt::darkGray);
+    downloadInfoLabel->setPalette(p);
+    progressBar->setMaximum(0);
+    tryAgainButton->hide();
+    connect(stopButton, SIGNAL(clicked()), this, SLOT(stop()));
+    connect(openButton, SIGNAL(clicked()), this, SLOT(open()));
+    connect(tryAgainButton, SIGNAL(clicked()), this, SLOT(tryAgain()));
+
+    init();
+}
+
+void DownloadItem::init()
+{
+    if (!m_reply)
+        return;
+
+    // attach to the m_reply
+    m_url = m_reply->url();
+    m_reply->setParent(this);
+    connect(m_reply, SIGNAL(readyRead()), this, SLOT(downloadReadyRead()));
+    connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
+            this, SLOT(error(QNetworkReply::NetworkError)));
+    connect(m_reply, SIGNAL(downloadProgress(qint64, qint64)),
+            this, SLOT(downloadProgress(qint64, qint64)));
+    connect(m_reply, SIGNAL(metaDataChanged()),
+            this, SLOT(metaDataChanged()));
+    connect(m_reply, SIGNAL(finished()),
+            this, SLOT(finished()));
+
+    // reset info
+    downloadInfoLabel->clear();
+    progressBar->setValue(0);
+    getFileName();
+
+    // start timer for the download estimation
+    m_downloadTime.start();
+
+    if (m_reply->error() != QNetworkReply::NoError) {
+        error(m_reply->error());
+        finished();
+    }
+}
+
+void DownloadItem::getFileName()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("downloadmanager"));
+    QString defaultLocation = QDesktopServices::storageLocation(QDesktopServices::DesktopLocation);
+    QString downloadDirectory = settings.value(QLatin1String("downloadDirectory"), defaultLocation).toString();
+    if (!downloadDirectory.isEmpty())
+        downloadDirectory += QLatin1Char('/');
+
+    QString defaultFileName = saveFileName(downloadDirectory);
+    QString fileName = defaultFileName;
+    if (m_requestFileName) {
+        fileName = QFileDialog::getSaveFileName(this, tr("Save File"), defaultFileName);
+        if (fileName.isEmpty()) {
+            m_reply->close();
+            fileNameLabel->setText(tr("Download canceled: %1").arg(QFileInfo(defaultFileName).fileName()));
+            return;
+        }
+    }
+    m_output.setFileName(fileName);
+    fileNameLabel->setText(QFileInfo(m_output.fileName()).fileName());
+    if (m_requestFileName)
+        downloadReadyRead();
+}
+
+QString DownloadItem::saveFileName(const QString &directory) const
+{
+    // Move this function into QNetworkReply to also get file name sent from the server
+    QString path = m_url.path();
+    QFileInfo info(path);
+    QString baseName = info.completeBaseName();
+    QString endName = info.suffix();
+
+    if (baseName.isEmpty()) {
+        baseName = QLatin1String("unnamed_download");
+        qDebug() << "DownloadManager:: downloading unknown file:" << m_url;
+    }
+    QString name = directory + baseName + QLatin1Char('.') + endName;
+    if (QFile::exists(name)) {
+        // already exists, don't overwrite
+        int i = 1;
+        do {
+            name = directory + baseName + QLatin1Char('-') + QString::number(i++) + QLatin1Char('.') + endName;
+        } while (QFile::exists(name));
+    }
+    return name;
+}
+
+
+void DownloadItem::stop()
+{
+    setUpdatesEnabled(false);
+    stopButton->setEnabled(false);
+    stopButton->hide();
+    tryAgainButton->setEnabled(true);
+    tryAgainButton->show();
+    setUpdatesEnabled(true);
+    m_reply->abort();
+}
+
+void DownloadItem::open()
+{
+    QFileInfo info(m_output);
+    QUrl url = QUrl::fromLocalFile(info.absolutePath());
+    QDesktopServices::openUrl(url);
+}
+
+void DownloadItem::tryAgain()
+{
+    if (!tryAgainButton->isEnabled())
+        return;
+
+    tryAgainButton->setEnabled(false);
+    tryAgainButton->setVisible(false);
+    stopButton->setEnabled(true);
+    stopButton->setVisible(true);
+    progressBar->setVisible(true);
+
+    QNetworkReply *r = BrowserApplication::networkAccessManager()->get(QNetworkRequest(m_url));
+    if (m_reply)
+        m_reply->deleteLater();
+    if (m_output.exists())
+        m_output.remove();
+    m_reply = r;
+    init();
+    emit statusChanged();
+}
+
+void DownloadItem::downloadReadyRead()
+{
+    if (m_requestFileName && m_output.fileName().isEmpty())
+        return;
+    if (!m_output.isOpen()) {
+        // in case someone else has already put a file there
+        if (!m_requestFileName)
+            getFileName();
+        if (!m_output.open(QIODevice::WriteOnly)) {
+            downloadInfoLabel->setText(tr("Error opening save file: %1")
+                    .arg(m_output.errorString()));
+            stopButton->click();
+            emit statusChanged();
+            return;
+        }
+        emit statusChanged();
+    }
+    if (-1 == m_output.write(m_reply->readAll())) {
+        downloadInfoLabel->setText(tr("Error saving: %1")
+                .arg(m_output.errorString()));
+        stopButton->click();
+    }
+}
+
+void DownloadItem::error(QNetworkReply::NetworkError)
+{
+    qDebug() << "DownloadItem::error" << m_reply->errorString() << m_url;
+    downloadInfoLabel->setText(tr("Network Error: %1").arg(m_reply->errorString()));
+    tryAgainButton->setEnabled(true);
+    tryAgainButton->setVisible(true);
+}
+
+void DownloadItem::metaDataChanged()
+{
+    qDebug() << "DownloadItem::metaDataChanged: not handled.";
+}
+
+void DownloadItem::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
+{
+    m_bytesReceived = bytesReceived;
+    if (bytesTotal == -1) {
+        progressBar->setValue(0);
+        progressBar->setMaximum(0);
+    } else {
+        progressBar->setValue(bytesReceived);
+        progressBar->setMaximum(bytesTotal);
+    }
+    updateInfoLabel();
+}
+
+void DownloadItem::updateInfoLabel()
+{
+    if (m_reply->error() == QNetworkReply::NoError)
+        return;
+
+    qint64 bytesTotal = progressBar->maximum();
+    bool running = !downloadedSuccessfully();
+
+    // update info label
+    double speed = m_bytesReceived * 1000.0 / m_downloadTime.elapsed();
+    double timeRemaining = ((double)(bytesTotal - m_bytesReceived)) / speed;
+    QString timeRemainingString = tr("seconds");
+    if (timeRemaining > 60) {
+        timeRemaining = timeRemaining / 60;
+        timeRemainingString = tr("minutes");
+    }
+    timeRemaining = floor(timeRemaining);
+
+    // When downloading the eta should never be 0
+    if (timeRemaining == 0)
+        timeRemaining = 1;
+
+    QString info;
+    if (running) {
+        QString remaining;
+        if (bytesTotal != 0)
+            remaining = tr("- %4 %5 remaining")
+            .arg(timeRemaining)
+            .arg(timeRemainingString);
+        info = QString(tr("%1 of %2 (%3/sec) %4"))
+            .arg(dataString(m_bytesReceived))
+            .arg(bytesTotal == 0 ? tr("?") : dataString(bytesTotal))
+            .arg(dataString((int)speed))
+            .arg(remaining);
+    } else {
+        if (m_bytesReceived == bytesTotal)
+            info = dataString(m_output.size());
+        else
+            info = tr("%1 of %2 - Stopped")
+                .arg(dataString(m_bytesReceived))
+                .arg(dataString(bytesTotal));
+    }
+    downloadInfoLabel->setText(info);
+}
+
+QString DownloadItem::dataString(int size) const
+{
+    QString unit;
+    if (size < 1024) {
+        unit = tr("bytes");
+    } else if (size < 1024*1024) {
+        size /= 1024;
+        unit = tr("kB");
+    } else {
+        size /= 1024*1024;
+        unit = tr("MB");
+    }
+    return QString(QLatin1String("%1 %2")).arg(size).arg(unit);
+}
+
+bool DownloadItem::downloading() const
+{
+    return (progressBar->isVisible());
+}
+
+bool DownloadItem::downloadedSuccessfully() const
+{
+    return (stopButton->isHidden() && tryAgainButton->isHidden());
+}
+
+void DownloadItem::finished()
+{
+    progressBar->hide();
+    stopButton->setEnabled(false);
+    stopButton->hide();
+    m_output.close();
+    updateInfoLabel();
+    emit statusChanged();
+}
+
+/*!
+    DownloadManager is a Dialog that contains a list of DownloadItems
+
+    It is a basic download manager.  It only downloads the file, doesn't do BitTorrent,
+    extract zipped files or anything fancy.
+  */
+DownloadManager::DownloadManager(QWidget *parent)
+    : QDialog(parent)
+    , m_autoSaver(new AutoSaver(this))
+    , m_manager(BrowserApplication::networkAccessManager())
+    , m_iconProvider(0)
+    , m_removePolicy(Never)
+{
+    setupUi(this);
+    downloadsView->setShowGrid(false);
+    downloadsView->verticalHeader()->hide();
+    downloadsView->horizontalHeader()->hide();
+    downloadsView->setAlternatingRowColors(true);
+    downloadsView->horizontalHeader()->setStretchLastSection(true);
+    m_model = new DownloadModel(this);
+    downloadsView->setModel(m_model);
+    connect(cleanupButton, SIGNAL(clicked()), this, SLOT(cleanup()));
+    load();
+}
+
+DownloadManager::~DownloadManager()
+{
+    m_autoSaver->changeOccurred();
+    m_autoSaver->saveIfNeccessary();
+    if (m_iconProvider)
+        delete m_iconProvider;
+}
+
+int DownloadManager::activeDownloads() const
+{
+    int count = 0;
+    for (int i = 0; i < m_downloads.count(); ++i) {
+        if (m_downloads.at(i)->stopButton->isEnabled())
+            ++count;
+    }
+    return count;
+}
+
+void DownloadManager::download(const QNetworkRequest &request, bool requestFileName)
+{
+    if (request.url().isEmpty())
+        return;
+    handleUnsupportedContent(m_manager->get(request), requestFileName);
+}
+
+void DownloadManager::handleUnsupportedContent(QNetworkReply *reply, bool requestFileName)
+{
+    if (!reply || reply->url().isEmpty())
+        return;
+    QVariant header = reply->header(QNetworkRequest::ContentLengthHeader);
+    bool ok;
+    int size = header.toInt(&ok);
+    if (ok && size == 0)
+        return;
+
+    qDebug() << "DownloadManager::handleUnsupportedContent" << reply->url() << "requestFileName" << requestFileName;
+    DownloadItem *item = new DownloadItem(reply, requestFileName, this);
+    addItem(item);
+}
+
+void DownloadManager::addItem(DownloadItem *item)
+{
+    connect(item, SIGNAL(statusChanged()), this, SLOT(updateRow()));
+    int row = m_downloads.count();
+    m_model->beginInsertRows(QModelIndex(), row, row);
+    m_downloads.append(item);
+    m_model->endInsertRows();
+    updateItemCount();
+    if (row == 0)
+        show();
+    downloadsView->setIndexWidget(m_model->index(row, 0), item);
+    QIcon icon = style()->standardIcon(QStyle::SP_FileIcon);
+    item->fileIcon->setPixmap(icon.pixmap(48, 48));
+    downloadsView->setRowHeight(row, item->sizeHint().height());
+}
+
+void DownloadManager::updateRow()
+{
+    DownloadItem *item = qobject_cast<DownloadItem*>(sender());
+    int row = m_downloads.indexOf(item);
+    if (-1 == row)
+        return;
+    if (!m_iconProvider)
+        m_iconProvider = new QFileIconProvider();
+    QIcon icon = m_iconProvider->icon(item->m_output.fileName());
+    if (icon.isNull())
+        icon = style()->standardIcon(QStyle::SP_FileIcon);
+    item->fileIcon->setPixmap(icon.pixmap(48, 48));
+    downloadsView->setRowHeight(row, item->minimumSizeHint().height());
+
+    bool remove = false;
+    QWebSettings *globalSettings = QWebSettings::globalSettings();
+    if (!item->downloading()
+        && globalSettings->testAttribute(QWebSettings::PrivateBrowsingEnabled))
+        remove = true;
+
+    if (item->downloadedSuccessfully()
+        && removePolicy() == DownloadManager::SuccessFullDownload) {
+        remove = true;
+    }
+    if (remove)
+        m_model->removeRow(row);
+
+    cleanupButton->setEnabled(m_downloads.count() - activeDownloads() > 0);
+}
+
+DownloadManager::RemovePolicy DownloadManager::removePolicy() const
+{
+    return m_removePolicy;
+}
+
+void DownloadManager::setRemovePolicy(RemovePolicy policy)
+{
+    if (policy == m_removePolicy)
+        return;
+    m_removePolicy = policy;
+    m_autoSaver->changeOccurred();
+}
+
+void DownloadManager::save() const
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("downloadmanager"));
+    QMetaEnum removePolicyEnum = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("RemovePolicy"));
+    settings.setValue(QLatin1String("removeDownloadsPolicy"), QLatin1String(removePolicyEnum.valueToKey(m_removePolicy)));
+    settings.setValue(QLatin1String("size"), size());
+    if (m_removePolicy == Exit)
+        return;
+
+    for (int i = 0; i < m_downloads.count(); ++i) {
+        QString key = QString(QLatin1String("download_%1_")).arg(i);
+        settings.setValue(key + QLatin1String("url"), m_downloads[i]->m_url);
+        settings.setValue(key + QLatin1String("location"), QFileInfo(m_downloads[i]->m_output).filePath());
+        settings.setValue(key + QLatin1String("done"), m_downloads[i]->downloadedSuccessfully());
+    }
+    int i = m_downloads.count();
+    QString key = QString(QLatin1String("download_%1_")).arg(i);
+    while (settings.contains(key + QLatin1String("url"))) {
+        settings.remove(key + QLatin1String("url"));
+        settings.remove(key + QLatin1String("location"));
+        settings.remove(key + QLatin1String("done"));
+        key = QString(QLatin1String("download_%1_")).arg(++i);
+    }
+}
+
+void DownloadManager::load()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("downloadmanager"));
+    QSize size = settings.value(QLatin1String("size")).toSize();
+    if (size.isValid())
+        resize(size);
+    QByteArray value = settings.value(QLatin1String("removeDownloadsPolicy"), QLatin1String("Never")).toByteArray();
+    QMetaEnum removePolicyEnum = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("RemovePolicy"));
+    m_removePolicy = removePolicyEnum.keyToValue(value) == -1 ?
+                        Never :
+                        static_cast<RemovePolicy>(removePolicyEnum.keyToValue(value));
+
+    int i = 0;
+    QString key = QString(QLatin1String("download_%1_")).arg(i);
+    while (settings.contains(key + QLatin1String("url"))) {
+        QUrl url = settings.value(key + QLatin1String("url")).toUrl();
+        QString fileName = settings.value(key + QLatin1String("location")).toString();
+        bool done = settings.value(key + QLatin1String("done"), true).toBool();
+        if (!url.isEmpty() && !fileName.isEmpty()) {
+            DownloadItem *item = new DownloadItem(0, this);
+            item->m_output.setFileName(fileName);
+            item->fileNameLabel->setText(QFileInfo(item->m_output.fileName()).fileName());
+            item->m_url = url;
+            item->stopButton->setVisible(false);
+            item->stopButton->setEnabled(false);
+            item->tryAgainButton->setVisible(!done);
+            item->tryAgainButton->setEnabled(!done);
+            item->progressBar->setVisible(!done);
+            addItem(item);
+        }
+        key = QString(QLatin1String("download_%1_")).arg(++i);
+    }
+    cleanupButton->setEnabled(m_downloads.count() - activeDownloads() > 0);
+}
+
+void DownloadManager::cleanup()
+{
+    if (m_downloads.isEmpty())
+        return;
+    m_model->removeRows(0, m_downloads.count());
+    updateItemCount();
+    if (m_downloads.isEmpty() && m_iconProvider) {
+        delete m_iconProvider;
+        m_iconProvider = 0;
+    }
+    m_autoSaver->changeOccurred();
+}
+
+void DownloadManager::updateItemCount()
+{
+    int count = m_downloads.count();
+    itemCount->setText(count == 1 ? tr("1 Download") : tr("%1 Downloads").arg(count));
+}
+
+DownloadModel::DownloadModel(DownloadManager *downloadManager, QObject *parent)
+    : QAbstractListModel(parent)
+    , m_downloadManager(downloadManager)
+{
+}
+
+QVariant DownloadModel::data(const QModelIndex &index, int role) const
+{
+    if (index.row() < 0 || index.row() >= rowCount(index.parent()))
+        return QVariant();
+    if (role == Qt::ToolTipRole)
+        if (!m_downloadManager->m_downloads.at(index.row())->downloadedSuccessfully())
+            return m_downloadManager->m_downloads.at(index.row())->downloadInfoLabel->text();
+    return QVariant();
+}
+
+int DownloadModel::rowCount(const QModelIndex &parent) const
+{
+    return (parent.isValid()) ? 0 : m_downloadManager->m_downloads.count();
+}
+
+bool DownloadModel::removeRows(int row, int count, const QModelIndex &parent)
+{
+    if (parent.isValid())
+        return false;
+
+    int lastRow = row + count - 1;
+    for (int i = lastRow; i >= row; --i) {
+        if (m_downloadManager->m_downloads.at(i)->downloadedSuccessfully()
+            || m_downloadManager->m_downloads.at(i)->tryAgainButton->isEnabled()) {
+            beginRemoveRows(parent, i, i);
+            m_downloadManager->m_downloads.takeAt(i)->deleteLater();
+            endRemoveRows();
+        }
+    }
+    m_downloadManager->m_autoSaver->changeOccurred();
+    return true;
+}
+
diff --git a/examples/gestures/browser/downloadmanager.h b/examples/gestures/browser/downloadmanager.h
new file mode 100644
index 0000000..80a451c
--- /dev/null
+++ b/examples/gestures/browser/downloadmanager.h
@@ -0,0 +1,162 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DOWNLOADMANAGER_H
+#define DOWNLOADMANAGER_H
+
+#include "ui_downloads.h"
+#include "ui_downloaditem.h"
+
+#include <QtNetwork/QNetworkReply>
+
+#include <QtCore/QFile>
+#include <QtCore/QTime>
+
+class DownloadItem : public QWidget, public Ui_DownloadItem
+{
+    Q_OBJECT
+
+signals:
+    void statusChanged();
+
+public:
+    DownloadItem(QNetworkReply *reply = 0, bool requestFileName = false, QWidget *parent = 0);
+    bool downloading() const;
+    bool downloadedSuccessfully() const;
+
+    QUrl m_url;
+
+    QFile m_output;
+    QNetworkReply *m_reply;
+
+private slots:
+    void stop();
+    void tryAgain();
+    void open();
+
+    void downloadReadyRead();
+    void error(QNetworkReply::NetworkError code);
+    void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
+    void metaDataChanged();
+    void finished();
+
+private:
+    void getFileName();
+    void init();
+    void updateInfoLabel();
+    QString dataString(int size) const;
+
+    QString saveFileName(const QString &directory) const;
+
+    bool m_requestFileName;
+    qint64 m_bytesReceived;
+    QTime m_downloadTime;
+};
+
+class AutoSaver;
+class DownloadModel;
+QT_BEGIN_NAMESPACE
+class QFileIconProvider;
+QT_END_NAMESPACE
+
+class DownloadManager : public QDialog, public Ui_DownloadDialog
+{
+    Q_OBJECT
+    Q_PROPERTY(RemovePolicy removePolicy READ removePolicy WRITE setRemovePolicy)
+    Q_ENUMS(RemovePolicy)
+
+public:
+    enum RemovePolicy {
+        Never,
+        Exit,
+        SuccessFullDownload
+    };
+
+    DownloadManager(QWidget *parent = 0);
+    ~DownloadManager();
+    int activeDownloads() const;
+
+    RemovePolicy removePolicy() const;
+    void setRemovePolicy(RemovePolicy policy);
+
+public slots:
+    void download(const QNetworkRequest &request, bool requestFileName = false);
+    inline void download(const QUrl &url, bool requestFileName = false)
+        { download(QNetworkRequest(url), requestFileName); }
+    void handleUnsupportedContent(QNetworkReply *reply, bool requestFileName = false);
+    void cleanup();
+
+private slots:
+    void save() const;
+    void updateRow();
+
+private:
+    void addItem(DownloadItem *item);
+    void updateItemCount();
+    void load();
+
+    AutoSaver *m_autoSaver;
+    DownloadModel *m_model;
+    QNetworkAccessManager *m_manager;
+    QFileIconProvider *m_iconProvider;
+    QList<DownloadItem*> m_downloads;
+    RemovePolicy m_removePolicy;
+    friend class DownloadModel;
+};
+
+class DownloadModel : public QAbstractListModel
+{
+    friend class DownloadManager;
+    Q_OBJECT
+
+public:
+    DownloadModel(DownloadManager *downloadManager, QObject *parent = 0);
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
+
+private:
+    DownloadManager *m_downloadManager;
+
+};
+
+#endif // DOWNLOADMANAGER_H
+
diff --git a/examples/gestures/browser/downloads.ui b/examples/gestures/browser/downloads.ui
new file mode 100644
index 0000000..a2e2569
--- /dev/null
+++ b/examples/gestures/browser/downloads.ui
@@ -0,0 +1,83 @@
+<ui version="4.0" >
+ <class>DownloadDialog</class>
+ <widget class="QDialog" name="DownloadDialog" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>332</width>
+    <height>252</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Downloads</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout" >
+   <property name="margin" >
+    <number>0</number>
+   </property>
+   <property name="spacing" >
+    <number>0</number>
+   </property>
+   <item row="0" column="0" colspan="3" >
+    <widget class="EditTableView" name="downloadsView" />
+   </item>
+   <item row="1" column="0" >
+    <layout class="QHBoxLayout" name="horizontalLayout" >
+     <item>
+      <widget class="QPushButton" name="cleanupButton" >
+       <property name="enabled" >
+        <bool>false</bool>
+       </property>
+       <property name="text" >
+        <string>Clean up</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer>
+       <property name="orientation" >
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0" >
+        <size>
+         <width>58</width>
+         <height>24</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+    </layout>
+   </item>
+   <item row="1" column="1" >
+    <widget class="QLabel" name="itemCount" >
+     <property name="text" >
+      <string>0 Items</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="2" >
+    <spacer name="horizontalSpacer" >
+     <property name="orientation" >
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="sizeHint" stdset="0" >
+      <size>
+       <width>148</width>
+       <height>20</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>EditTableView</class>
+   <extends>QTableView</extends>
+   <header>edittableview.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/examples/gestures/browser/edittableview.cpp b/examples/gestures/browser/edittableview.cpp
new file mode 100644
index 0000000..72c367d
--- /dev/null
+++ b/examples/gestures/browser/edittableview.cpp
@@ -0,0 +1,78 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "edittableview.h"
+#include <QtGui/QKeyEvent>
+
+EditTableView::EditTableView(QWidget *parent)
+    : QTableView(parent)
+{
+}
+
+void EditTableView::keyPressEvent(QKeyEvent *event)
+{
+    if ((event->key() == Qt::Key_Delete
+        || event->key() == Qt::Key_Backspace)
+        && model()) {
+        removeOne();
+    } else {
+        QAbstractItemView::keyPressEvent(event);
+    }
+}
+
+void EditTableView::removeOne()
+{
+    if (!model() || !selectionModel())
+        return;
+    int row = currentIndex().row();
+    model()->removeRow(row, rootIndex());
+    QModelIndex idx = model()->index(row, 0, rootIndex());
+    if (!idx.isValid())
+        idx = model()->index(row - 1, 0, rootIndex());
+    selectionModel()->select(idx, QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows);
+}
+
+void EditTableView::removeAll()
+{
+    if (model())
+        model()->removeRows(0, model()->rowCount(rootIndex()), rootIndex());
+}
+
diff --git a/examples/gestures/browser/edittableview.h b/examples/gestures/browser/edittableview.h
new file mode 100644
index 0000000..359c548
--- /dev/null
+++ b/examples/gestures/browser/edittableview.h
@@ -0,0 +1,61 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef EDITTABLEVIEW_H
+#define EDITTABLEVIEW_H
+
+#include <QtGui/QTableView>
+
+class EditTableView : public QTableView
+{
+    Q_OBJECT
+
+public:
+    EditTableView(QWidget *parent = 0);
+    void keyPressEvent(QKeyEvent *event);
+
+public slots:
+    void removeOne();
+    void removeAll();
+};
+
+#endif // EDITTABLEVIEW_H
+
diff --git a/examples/gestures/browser/edittreeview.cpp b/examples/gestures/browser/edittreeview.cpp
new file mode 100644
index 0000000..dacb28e
--- /dev/null
+++ b/examples/gestures/browser/edittreeview.cpp
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "edittreeview.h"
+
+#include <QtGui/QKeyEvent>
+
+EditTreeView::EditTreeView(QWidget *parent)
+    : QTreeView(parent)
+{
+}
+
+void EditTreeView::keyPressEvent(QKeyEvent *event)
+{
+    if ((event->key() == Qt::Key_Delete
+        || event->key() == Qt::Key_Backspace)
+        && model()) {
+        removeOne();
+    } else {
+        QAbstractItemView::keyPressEvent(event);
+    }
+}
+
+void EditTreeView::removeOne()
+{
+    if (!model())
+        return;
+    QModelIndex ci = currentIndex();
+    int row = ci.row();
+    model()->removeRow(row, ci.parent());
+}
+
+void EditTreeView::removeAll()
+{
+    if (!model())
+        return;
+    model()->removeRows(0, model()->rowCount(rootIndex()), rootIndex());
+}
+
diff --git a/examples/gestures/browser/edittreeview.h b/examples/gestures/browser/edittreeview.h
new file mode 100644
index 0000000..a0b776c
--- /dev/null
+++ b/examples/gestures/browser/edittreeview.h
@@ -0,0 +1,61 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef EDITTREEVIEW_H
+#define EDITTREEVIEW_H
+
+#include <QtGui/QTreeView>
+
+class EditTreeView : public QTreeView
+{
+    Q_OBJECT
+
+public:
+    EditTreeView(QWidget *parent = 0);
+    void keyPressEvent(QKeyEvent *event);
+
+public slots:
+    void removeOne();
+    void removeAll();
+};
+
+#endif // EDITTREEVIEW_H
+
diff --git a/examples/gestures/browser/history.cpp b/examples/gestures/browser/history.cpp
new file mode 100644
index 0000000..ef7e834
--- /dev/null
+++ b/examples/gestures/browser/history.cpp
@@ -0,0 +1,1282 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "history.h"
+
+#include "autosaver.h"
+#include "browserapplication.h"
+
+#include <QtCore/QBuffer>
+#include <QtCore/QDir>
+#include <QtCore/QFile>
+#include <QtCore/QFileInfo>
+#include <QtCore/QSettings>
+#include <QtCore/QTemporaryFile>
+#include <QtCore/QTextStream>
+
+#include <QtCore/QtAlgorithms>
+
+#include <QtGui/QClipboard>
+#include <QtGui/QDesktopServices>
+#include <QtGui/QHeaderView>
+#include <QtGui/QStyle>
+
+#include <QtWebKit/QWebHistoryInterface>
+#include <QtWebKit/QWebSettings>
+
+#include <QtCore/QDebug>
+
+static const unsigned int HISTORY_VERSION = 23;
+
+HistoryManager::HistoryManager(QObject *parent)
+    : QWebHistoryInterface(parent)
+    , m_saveTimer(new AutoSaver(this))
+    , m_historyLimit(30)
+    , m_historyModel(0)
+    , m_historyFilterModel(0)
+    , m_historyTreeModel(0)
+{
+    m_expiredTimer.setSingleShot(true);
+    connect(&m_expiredTimer, SIGNAL(timeout()),
+            this, SLOT(checkForExpired()));
+    connect(this, SIGNAL(entryAdded(const HistoryItem &)),
+            m_saveTimer, SLOT(changeOccurred()));
+    connect(this, SIGNAL(entryRemoved(const HistoryItem &)),
+            m_saveTimer, SLOT(changeOccurred()));
+    load();
+
+    m_historyModel = new HistoryModel(this, this);
+    m_historyFilterModel = new HistoryFilterModel(m_historyModel, this);
+    m_historyTreeModel = new HistoryTreeModel(m_historyFilterModel, this);
+
+    // QWebHistoryInterface will delete the history manager
+    QWebHistoryInterface::setDefaultInterface(this);
+}
+
+HistoryManager::~HistoryManager()
+{
+    m_saveTimer->saveIfNeccessary();
+}
+
+QList<HistoryItem> HistoryManager::history() const
+{
+    return m_history;
+}
+
+bool HistoryManager::historyContains(const QString &url) const
+{
+    return m_historyFilterModel->historyContains(url);
+}
+
+void HistoryManager::addHistoryEntry(const QString &url)
+{
+    QUrl cleanUrl(url);
+    cleanUrl.setPassword(QString());
+    cleanUrl.setHost(cleanUrl.host().toLower());
+    HistoryItem item(cleanUrl.toString(), QDateTime::currentDateTime());
+    addHistoryItem(item);
+}
+
+void HistoryManager::setHistory(const QList<HistoryItem> &history, bool loadedAndSorted)
+{
+    m_history = history;
+
+    // verify that it is sorted by date
+    if (!loadedAndSorted)
+        qSort(m_history.begin(), m_history.end());
+
+    checkForExpired();
+
+    if (loadedAndSorted) {
+        m_lastSavedUrl = m_history.value(0).url;
+    } else {
+        m_lastSavedUrl = QString();
+        m_saveTimer->changeOccurred();
+    }
+    emit historyReset();
+}
+
+HistoryModel *HistoryManager::historyModel() const
+{
+    return m_historyModel;
+}
+
+HistoryFilterModel *HistoryManager::historyFilterModel() const
+{
+    return m_historyFilterModel;
+}
+
+HistoryTreeModel *HistoryManager::historyTreeModel() const
+{
+    return m_historyTreeModel;
+}
+
+void HistoryManager::checkForExpired()
+{
+    if (m_historyLimit < 0 || m_history.isEmpty())
+        return;
+
+    QDateTime now = QDateTime::currentDateTime();
+    int nextTimeout = 0;
+
+    while (!m_history.isEmpty()) {
+        QDateTime checkForExpired = m_history.last().dateTime;
+        checkForExpired.setDate(checkForExpired.date().addDays(m_historyLimit));
+        if (now.daysTo(checkForExpired) > 7) {
+            // check at most in a week to prevent int overflows on the timer
+            nextTimeout = 7 * 86400;
+        } else {
+            nextTimeout = now.secsTo(checkForExpired);
+        }
+        if (nextTimeout > 0)
+            break;
+        HistoryItem item = m_history.takeLast();
+        // remove from saved file also
+        m_lastSavedUrl = QString();
+        emit entryRemoved(item);
+    }
+
+    if (nextTimeout > 0)
+        m_expiredTimer.start(nextTimeout * 1000);
+}
+
+void HistoryManager::addHistoryItem(const HistoryItem &item)
+{
+    QWebSettings *globalSettings = QWebSettings::globalSettings();
+    if (globalSettings->testAttribute(QWebSettings::PrivateBrowsingEnabled))
+        return;
+
+    m_history.prepend(item);
+    emit entryAdded(item);
+    if (m_history.count() == 1)
+        checkForExpired();
+}
+
+void HistoryManager::updateHistoryItem(const QUrl &url, const QString &title)
+{
+    for (int i = 0; i < m_history.count(); ++i) {
+        if (url == m_history.at(i).url) {
+            m_history[i].title = title;
+            m_saveTimer->changeOccurred();
+            if (m_lastSavedUrl.isEmpty())
+                m_lastSavedUrl = m_history.at(i).url;
+            emit entryUpdated(i);
+            break;
+        }
+    }
+}
+
+int HistoryManager::historyLimit() const
+{
+    return m_historyLimit;
+}
+
+void HistoryManager::setHistoryLimit(int limit)
+{
+    if (m_historyLimit == limit)
+        return;
+    m_historyLimit = limit;
+    checkForExpired();
+    m_saveTimer->changeOccurred();
+}
+
+void HistoryManager::clear()
+{
+    m_history.clear();
+    m_lastSavedUrl = QString();
+    m_saveTimer->changeOccurred();
+    m_saveTimer->saveIfNeccessary();
+    historyReset();
+}
+
+void HistoryManager::loadSettings()
+{
+    // load settings
+    QSettings settings;
+    settings.beginGroup(QLatin1String("history"));
+    m_historyLimit = settings.value(QLatin1String("historyLimit"), 30).toInt();
+}
+
+void HistoryManager::load()
+{
+    loadSettings();
+
+    QFile historyFile(QDesktopServices::storageLocation(QDesktopServices::DataLocation)
+        + QLatin1String("/history"));
+    if (!historyFile.exists())
+        return;
+    if (!historyFile.open(QFile::ReadOnly)) {
+        qWarning() << "Unable to open history file" << historyFile.fileName();
+        return;
+    }
+
+    QList<HistoryItem> list;
+    QDataStream in(&historyFile);
+    // Double check that the history file is sorted as it is read in
+    bool needToSort = false;
+    HistoryItem lastInsertedItem;
+    QByteArray data;
+    QDataStream stream;
+    QBuffer buffer;
+    stream.setDevice(&buffer);
+    while (!historyFile.atEnd()) {
+        in >> data;
+        buffer.close();
+        buffer.setBuffer(&data);
+        buffer.open(QIODevice::ReadOnly);
+        quint32 ver;
+        stream >> ver;
+        if (ver != HISTORY_VERSION)
+            continue;
+        HistoryItem item;
+        stream >> item.url;
+        stream >> item.dateTime;
+        stream >> item.title;
+
+        if (!item.dateTime.isValid())
+            continue;
+
+        if (item == lastInsertedItem) {
+            if (lastInsertedItem.title.isEmpty() && !list.isEmpty())
+                list[0].title = item.title;
+            continue;
+        }
+
+        if (!needToSort && !list.isEmpty() && lastInsertedItem < item)
+            needToSort = true;
+
+        list.prepend(item);
+        lastInsertedItem = item;
+    }
+    if (needToSort)
+        qSort(list.begin(), list.end());
+
+    setHistory(list, true);
+
+    // If we had to sort re-write the whole history sorted
+    if (needToSort) {
+        m_lastSavedUrl = QString();
+        m_saveTimer->changeOccurred();
+    }
+}
+
+void HistoryManager::save()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("history"));
+    settings.setValue(QLatin1String("historyLimit"), m_historyLimit);
+
+    bool saveAll = m_lastSavedUrl.isEmpty();
+    int first = m_history.count() - 1;
+    if (!saveAll) {
+        // find the first one to save
+        for (int i = 0; i < m_history.count(); ++i) {
+            if (m_history.at(i).url == m_lastSavedUrl) {
+                first = i - 1;
+                break;
+            }
+        }
+    }
+    if (first == m_history.count() - 1)
+        saveAll = true;
+
+    QString directory = QDesktopServices::storageLocation(QDesktopServices::DataLocation);
+    if (directory.isEmpty())
+        directory = QDir::homePath() + QLatin1String("/.") + QCoreApplication::applicationName();
+    if (!QFile::exists(directory)) {
+        QDir dir;
+        dir.mkpath(directory);
+    }
+
+    QFile historyFile(directory + QLatin1String("/history"));
+    // When saving everything use a temporary file to prevent possible data loss.
+    QTemporaryFile tempFile;
+    tempFile.setAutoRemove(false);
+    bool open = false;
+    if (saveAll) {
+        open = tempFile.open();
+    } else {
+        open = historyFile.open(QFile::Append);
+    }
+
+    if (!open) {
+        qWarning() << "Unable to open history file for saving"
+                   << (saveAll ? tempFile.fileName() : historyFile.fileName());
+        return;
+    }
+
+    QDataStream out(saveAll ? &tempFile : &historyFile);
+    for (int i = first; i >= 0; --i) {
+        QByteArray data;
+        QDataStream stream(&data, QIODevice::WriteOnly);
+        HistoryItem item = m_history.at(i);
+        stream << HISTORY_VERSION << item.url << item.dateTime << item.title;
+        out << data;
+    }
+    tempFile.close();
+
+    if (saveAll) {
+        if (historyFile.exists() && !historyFile.remove())
+            qWarning() << "History: error removing old history." << historyFile.errorString();
+        if (!tempFile.rename(historyFile.fileName()))
+            qWarning() << "History: error moving new history over old." << tempFile.errorString() << historyFile.fileName();
+    }
+    m_lastSavedUrl = m_history.value(0).url;
+}
+
+HistoryModel::HistoryModel(HistoryManager *history, QObject *parent)
+    : QAbstractTableModel(parent)
+    , m_history(history)
+{
+    Q_ASSERT(m_history);
+    connect(m_history, SIGNAL(historyReset()),
+            this, SLOT(historyReset()));
+    connect(m_history, SIGNAL(entryRemoved(const HistoryItem &)),
+            this, SLOT(historyReset()));
+
+    connect(m_history, SIGNAL(entryAdded(const HistoryItem &)),
+            this, SLOT(entryAdded()));
+    connect(m_history, SIGNAL(entryUpdated(int)),
+            this, SLOT(entryUpdated(int)));
+}
+
+void HistoryModel::historyReset()
+{
+    reset();
+}
+
+void HistoryModel::entryAdded()
+{
+    beginInsertRows(QModelIndex(), 0, 0);
+    endInsertRows();
+}
+
+void HistoryModel::entryUpdated(int offset)
+{
+    QModelIndex idx = index(offset, 0);
+    emit dataChanged(idx, idx);
+}
+
+QVariant HistoryModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    if (orientation == Qt::Horizontal
+        && role == Qt::DisplayRole) {
+        switch (section) {
+            case 0: return tr("Title");
+            case 1: return tr("Address");
+        }
+    }
+    return QAbstractTableModel::headerData(section, orientation, role);
+}
+
+QVariant HistoryModel::data(const QModelIndex &index, int role) const
+{
+    QList<HistoryItem> lst = m_history->history();
+    if (index.row() < 0 || index.row() >= lst.size())
+        return QVariant();
+
+    const HistoryItem &item = lst.at(index.row());
+    switch (role) {
+    case DateTimeRole:
+        return item.dateTime;
+    case DateRole:
+        return item.dateTime.date();
+    case UrlRole:
+        return QUrl(item.url);
+    case UrlStringRole:
+        return item.url;
+    case Qt::DisplayRole:
+    case Qt::EditRole: {
+        switch (index.column()) {
+            case 0:
+                // when there is no title try to generate one from the url
+                if (item.title.isEmpty()) {
+                    QString page = QFileInfo(QUrl(item.url).path()).fileName();
+                    if (!page.isEmpty())
+                        return page;
+                    return item.url;
+                }
+                return item.title;
+            case 1:
+                return item.url;
+        }
+        }
+    case Qt::DecorationRole:
+        if (index.column() == 0) {
+            return BrowserApplication::instance()->icon(item.url);
+        }
+    }
+    return QVariant();
+}
+
+int HistoryModel::columnCount(const QModelIndex &parent) const
+{
+    return (parent.isValid()) ? 0 : 2;
+}
+
+int HistoryModel::rowCount(const QModelIndex &parent) const
+{
+    return (parent.isValid()) ? 0 : m_history->history().count();
+}
+
+bool HistoryModel::removeRows(int row, int count, const QModelIndex &parent)
+{
+    if (parent.isValid())
+        return false;
+    int lastRow = row + count - 1;
+    beginRemoveRows(parent, row, lastRow);
+    QList<HistoryItem> lst = m_history->history();
+    for (int i = lastRow; i >= row; --i)
+        lst.removeAt(i);
+    disconnect(m_history, SIGNAL(historyReset()), this, SLOT(historyReset()));
+    m_history->setHistory(lst);
+    connect(m_history, SIGNAL(historyReset()), this, SLOT(historyReset()));
+    endRemoveRows();
+    return true;
+}
+
+#define MOVEDROWS 15
+
+/*
+    Maps the first bunch of items of the source model to the root
+*/
+HistoryMenuModel::HistoryMenuModel(HistoryTreeModel *sourceModel, QObject *parent)
+    : QAbstractProxyModel(parent)
+    , m_treeModel(sourceModel)
+{
+    setSourceModel(sourceModel);
+}
+
+int HistoryMenuModel::bumpedRows() const
+{
+    QModelIndex first = m_treeModel->index(0, 0);
+    if (!first.isValid())
+        return 0;
+    return qMin(m_treeModel->rowCount(first), MOVEDROWS);
+}
+
+int HistoryMenuModel::columnCount(const QModelIndex &parent) const
+{
+    return m_treeModel->columnCount(mapToSource(parent));
+}
+
+int HistoryMenuModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.column() > 0)
+        return 0;
+
+    if (!parent.isValid()) {
+        int folders = sourceModel()->rowCount();
+        int bumpedItems = bumpedRows();
+        if (bumpedItems <= MOVEDROWS
+            && bumpedItems == sourceModel()->rowCount(sourceModel()->index(0, 0)))
+            --folders;
+        return bumpedItems + folders;
+    }
+
+    if (parent.internalId() == -1) {
+        if (parent.row() < bumpedRows())
+            return 0;
+    }
+
+    QModelIndex idx = mapToSource(parent);
+    int defaultCount = sourceModel()->rowCount(idx);
+    if (idx == sourceModel()->index(0, 0))
+        return defaultCount - bumpedRows();
+    return defaultCount;
+}
+
+QModelIndex HistoryMenuModel::mapFromSource(const QModelIndex &sourceIndex) const
+{
+    // currently not used or autotested
+    Q_ASSERT(false);
+    int sr = m_treeModel->mapToSource(sourceIndex).row();
+    return createIndex(sourceIndex.row(), sourceIndex.column(), sr);
+}
+
+QModelIndex HistoryMenuModel::mapToSource(const QModelIndex &proxyIndex) const
+{
+    if (!proxyIndex.isValid())
+        return QModelIndex();
+
+    if (proxyIndex.internalId() == -1) {
+        int bumpedItems = bumpedRows();
+        if (proxyIndex.row() < bumpedItems)
+            return m_treeModel->index(proxyIndex.row(), proxyIndex.column(), m_treeModel->index(0, 0));
+        if (bumpedItems <= MOVEDROWS && bumpedItems == sourceModel()->rowCount(m_treeModel->index(0, 0)))
+            --bumpedItems;
+        return m_treeModel->index(proxyIndex.row() - bumpedItems, proxyIndex.column());
+    }
+
+    QModelIndex historyIndex = m_treeModel->sourceModel()->index(proxyIndex.internalId(), proxyIndex.column());
+    QModelIndex treeIndex = m_treeModel->mapFromSource(historyIndex);
+    return treeIndex;
+}
+
+QModelIndex HistoryMenuModel::index(int row, int column, const QModelIndex &parent) const
+{
+    if (row < 0
+        || column < 0 || column >= columnCount(parent)
+        || parent.column() > 0)
+        return QModelIndex();
+    if (!parent.isValid())
+        return createIndex(row, column, -1);
+
+    QModelIndex treeIndexParent = mapToSource(parent);
+
+    int bumpedItems = 0;
+    if (treeIndexParent == m_treeModel->index(0, 0))
+        bumpedItems = bumpedRows();
+    QModelIndex treeIndex = m_treeModel->index(row + bumpedItems, column, treeIndexParent);
+    QModelIndex historyIndex = m_treeModel->mapToSource(treeIndex);
+    int historyRow = historyIndex.row();
+    if (historyRow == -1)
+        historyRow = treeIndex.row();
+    return createIndex(row, column, historyRow);
+}
+
+QModelIndex HistoryMenuModel::parent(const QModelIndex &index) const
+{
+    int offset = index.internalId();
+    if (offset == -1 || !index.isValid())
+        return QModelIndex();
+
+    QModelIndex historyIndex = m_treeModel->sourceModel()->index(index.internalId(), 0);
+    QModelIndex treeIndex = m_treeModel->mapFromSource(historyIndex);
+    QModelIndex treeIndexParent = treeIndex.parent();
+
+    int sr = m_treeModel->mapToSource(treeIndexParent).row();
+    int bumpedItems = bumpedRows();
+    if (bumpedItems <= MOVEDROWS && bumpedItems == sourceModel()->rowCount(sourceModel()->index(0, 0)))
+        --bumpedItems;
+    return createIndex(bumpedItems + treeIndexParent.row(), treeIndexParent.column(), sr);
+}
+
+
+HistoryMenu::HistoryMenu(QWidget *parent)
+    : ModelMenu(parent)
+    , m_history(0)
+{
+    connect(this, SIGNAL(activated(const QModelIndex &)),
+            this, SLOT(activated(const QModelIndex &)));
+    setHoverRole(HistoryModel::UrlStringRole);
+}
+
+void HistoryMenu::activated(const QModelIndex &index)
+{
+    emit openUrl(index.data(HistoryModel::UrlRole).toUrl());
+}
+
+bool HistoryMenu::prePopulated()
+{
+    if (!m_history) {
+        m_history = BrowserApplication::historyManager();
+        m_historyMenuModel = new HistoryMenuModel(m_history->historyTreeModel(), this);
+        setModel(m_historyMenuModel);
+    }
+    // initial actions
+    for (int i = 0; i < m_initialActions.count(); ++i)
+        addAction(m_initialActions.at(i));
+    if (!m_initialActions.isEmpty())
+        addSeparator();
+    setFirstSeparator(m_historyMenuModel->bumpedRows());
+
+    return false;
+}
+
+void HistoryMenu::postPopulated()
+{
+    if (m_history->history().count() > 0)
+        addSeparator();
+
+    QAction *showAllAction = new QAction(tr("Show All History"), this);
+    connect(showAllAction, SIGNAL(triggered()), this, SLOT(showHistoryDialog()));
+    addAction(showAllAction);
+
+    QAction *clearAction = new QAction(tr("Clear History"), this);
+    connect(clearAction, SIGNAL(triggered()), m_history, SLOT(clear()));
+    addAction(clearAction);
+}
+
+void HistoryMenu::showHistoryDialog()
+{
+    HistoryDialog *dialog = new HistoryDialog(this);
+    connect(dialog, SIGNAL(openUrl(const QUrl&)),
+            this, SIGNAL(openUrl(const QUrl&)));
+    dialog->show();
+}
+
+void HistoryMenu::setInitialActions(QList<QAction*> actions)
+{
+    m_initialActions = actions;
+    for (int i = 0; i < m_initialActions.count(); ++i)
+        addAction(m_initialActions.at(i));
+}
+
+TreeProxyModel::TreeProxyModel(QObject *parent) : QSortFilterProxyModel(parent)
+{
+    setSortRole(HistoryModel::DateTimeRole);
+    setFilterCaseSensitivity(Qt::CaseInsensitive);
+}
+
+bool TreeProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
+{
+    if (!source_parent.isValid())
+        return true;
+    return QSortFilterProxyModel::filterAcceptsRow(source_row, source_parent);
+}
+
+HistoryDialog::HistoryDialog(QWidget *parent, HistoryManager *setHistory) : QDialog(parent)
+{
+    HistoryManager *history = setHistory;
+    if (!history)
+        history = BrowserApplication::historyManager();
+    setupUi(this);
+    tree->setUniformRowHeights(true);
+    tree->setSelectionBehavior(QAbstractItemView::SelectRows);
+    tree->setTextElideMode(Qt::ElideMiddle);
+    QAbstractItemModel *model = history->historyTreeModel();
+    TreeProxyModel *proxyModel = new TreeProxyModel(this);
+    connect(search, SIGNAL(textChanged(QString)),
+            proxyModel, SLOT(setFilterFixedString(QString)));
+    connect(removeButton, SIGNAL(clicked()), tree, SLOT(removeOne()));
+    connect(removeAllButton, SIGNAL(clicked()), history, SLOT(clear()));
+    proxyModel->setSourceModel(model);
+    tree->setModel(proxyModel);
+    tree->setExpanded(proxyModel->index(0, 0), true);
+    tree->setAlternatingRowColors(true);
+    QFontMetrics fm(font());
+    int header = fm.width(QLatin1Char('m')) * 40;
+    tree->header()->resizeSection(0, header);
+    tree->header()->setStretchLastSection(true);
+    connect(tree, SIGNAL(activated(const QModelIndex&)),
+            this, SLOT(open()));
+    tree->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(tree, SIGNAL(customContextMenuRequested(const QPoint &)),
+            this, SLOT(customContextMenuRequested(const QPoint &)));
+}
+
+void HistoryDialog::customContextMenuRequested(const QPoint &pos)
+{
+    QMenu menu;
+    QModelIndex index = tree->indexAt(pos);
+    index = index.sibling(index.row(), 0);
+    if (index.isValid() && !tree->model()->hasChildren(index)) {
+        menu.addAction(tr("Open"), this, SLOT(open()));
+        menu.addSeparator();
+        menu.addAction(tr("Copy"), this, SLOT(copy()));
+    }
+    menu.addAction(tr("Delete"), tree, SLOT(removeOne()));
+    menu.exec(QCursor::pos());
+}
+
+void HistoryDialog::open()
+{
+    QModelIndex index = tree->currentIndex();
+    if (!index.parent().isValid())
+        return;
+    emit openUrl(index.data(HistoryModel::UrlRole).toUrl());
+}
+
+void HistoryDialog::copy()
+{
+    QModelIndex index = tree->currentIndex();
+    if (!index.parent().isValid())
+        return;
+    QString url = index.data(HistoryModel::UrlStringRole).toString();
+
+    QClipboard *clipboard = QApplication::clipboard();
+    clipboard->setText(url);
+}
+
+HistoryFilterModel::HistoryFilterModel(QAbstractItemModel *sourceModel, QObject *parent)
+    : QAbstractProxyModel(parent),
+    m_loaded(false)
+{
+    setSourceModel(sourceModel);
+}
+
+int HistoryFilterModel::historyLocation(const QString &url) const
+{
+    load();
+    if (!m_historyHash.contains(url))
+        return 0;
+    return sourceModel()->rowCount() - m_historyHash.value(url);
+}
+
+QVariant HistoryFilterModel::data(const QModelIndex &index, int role) const
+{
+    return QAbstractProxyModel::data(index, role);
+}
+
+void HistoryFilterModel::setSourceModel(QAbstractItemModel *newSourceModel)
+{
+    if (sourceModel()) {
+        disconnect(sourceModel(), SIGNAL(modelReset()), this, SLOT(sourceReset()));
+        disconnect(sourceModel(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)),
+                   this, SLOT(dataChanged(const QModelIndex &, const QModelIndex &)));
+        disconnect(sourceModel(), SIGNAL(rowsInserted(const QModelIndex &, int, int)),
+                this, SLOT(sourceRowsInserted(const QModelIndex &, int, int)));
+        disconnect(sourceModel(), SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
+                this, SLOT(sourceRowsRemoved(const QModelIndex &, int, int)));
+    }
+
+    QAbstractProxyModel::setSourceModel(newSourceModel);
+
+    if (sourceModel()) {
+        m_loaded = false;
+        connect(sourceModel(), SIGNAL(modelReset()), this, SLOT(sourceReset()));
+        connect(sourceModel(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)),
+                   this, SLOT(sourceDataChanged(const QModelIndex &, const QModelIndex &)));
+        connect(sourceModel(), SIGNAL(rowsInserted(const QModelIndex &, int, int)),
+                this, SLOT(sourceRowsInserted(const QModelIndex &, int, int)));
+        connect(sourceModel(), SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
+                this, SLOT(sourceRowsRemoved(const QModelIndex &, int, int)));
+    }
+}
+
+void HistoryFilterModel::sourceDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
+{
+    emit dataChanged(mapFromSource(topLeft), mapFromSource(bottomRight));
+}
+
+QVariant HistoryFilterModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    return sourceModel()->headerData(section, orientation, role);
+}
+
+void HistoryFilterModel::sourceReset()
+{
+    m_loaded = false;
+    reset();
+}
+
+int HistoryFilterModel::rowCount(const QModelIndex &parent) const
+{
+    load();
+    if (parent.isValid())
+        return 0;
+    return m_historyHash.count();
+}
+
+int HistoryFilterModel::columnCount(const QModelIndex &parent) const
+{
+    return (parent.isValid()) ? 0 : 2;
+}
+
+QModelIndex HistoryFilterModel::mapToSource(const QModelIndex &proxyIndex) const
+{
+    load();
+    int sourceRow = sourceModel()->rowCount() - proxyIndex.internalId();
+    return sourceModel()->index(sourceRow, proxyIndex.column());
+}
+
+QModelIndex HistoryFilterModel::mapFromSource(const QModelIndex &sourceIndex) const
+{
+    load();
+    QString url = sourceIndex.data(HistoryModel::UrlStringRole).toString();
+    if (!m_historyHash.contains(url))
+        return QModelIndex();
+
+    // This can be done in a binary search, but we can't use qBinary find
+    // because it can't take: qBinaryFind(m_sourceRow.end(), m_sourceRow.begin(), v);
+    // so if this is a performance bottlneck then convert to binary search, until then
+    // the cleaner/easier to read code wins the day.
+    int realRow = -1;
+    int sourceModelRow = sourceModel()->rowCount() - sourceIndex.row();
+
+    for (int i = 0; i < m_sourceRow.count(); ++i) {
+        if (m_sourceRow.at(i) == sourceModelRow) {
+            realRow = i;
+            break;
+        }
+    }
+    if (realRow == -1)
+        return QModelIndex();
+
+    return createIndex(realRow, sourceIndex.column(), sourceModel()->rowCount() - sourceIndex.row());
+}
+
+QModelIndex HistoryFilterModel::index(int row, int column, const QModelIndex &parent) const
+{
+    load();
+    if (row < 0 || row >= rowCount(parent)
+        || column < 0 || column >= columnCount(parent))
+        return QModelIndex();
+
+    return createIndex(row, column, m_sourceRow[row]);
+}
+
+QModelIndex HistoryFilterModel::parent(const QModelIndex &) const
+{
+    return QModelIndex();
+}
+
+void HistoryFilterModel::load() const
+{
+    if (m_loaded)
+        return;
+    m_sourceRow.clear();
+    m_historyHash.clear();
+    m_historyHash.reserve(sourceModel()->rowCount());
+    for (int i = 0; i < sourceModel()->rowCount(); ++i) {
+        QModelIndex idx = sourceModel()->index(i, 0);
+        QString url = idx.data(HistoryModel::UrlStringRole).toString();
+        if (!m_historyHash.contains(url)) {
+            m_sourceRow.append(sourceModel()->rowCount() - i);
+            m_historyHash[url] = sourceModel()->rowCount() - i;
+        }
+    }
+    m_loaded = true;
+}
+
+void HistoryFilterModel::sourceRowsInserted(const QModelIndex &parent, int start, int end)
+{
+    Q_ASSERT(start == end && start == 0);
+    Q_UNUSED(end);
+    if (!m_loaded)
+        return;
+    QModelIndex idx = sourceModel()->index(start, 0, parent);
+    QString url = idx.data(HistoryModel::UrlStringRole).toString();
+    if (m_historyHash.contains(url)) {
+        int sourceRow = sourceModel()->rowCount() - m_historyHash[url];
+        int realRow = mapFromSource(sourceModel()->index(sourceRow, 0)).row();
+        beginRemoveRows(QModelIndex(), realRow, realRow);
+        m_sourceRow.removeAt(realRow);
+        m_historyHash.remove(url);
+        endRemoveRows();
+    }
+    beginInsertRows(QModelIndex(), 0, 0);
+    m_historyHash.insert(url, sourceModel()->rowCount() - start);
+    m_sourceRow.insert(0, sourceModel()->rowCount());
+    endInsertRows();
+}
+
+void HistoryFilterModel::sourceRowsRemoved(const QModelIndex &, int start, int end)
+{
+    Q_UNUSED(start);
+    Q_UNUSED(end);
+    sourceReset();
+}
+
+/*
+    Removing a continuous block of rows will remove filtered rows too as this is
+    the users intention.
+*/
+bool HistoryFilterModel::removeRows(int row, int count, const QModelIndex &parent)
+{
+    if (row < 0 || count <= 0 || row + count > rowCount(parent) || parent.isValid())
+        return false;
+    int lastRow = row + count - 1;
+    disconnect(sourceModel(), SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
+                this, SLOT(sourceRowsRemoved(const QModelIndex &, int, int)));
+    beginRemoveRows(parent, row, lastRow);
+    int oldCount = rowCount();
+    int start = sourceModel()->rowCount() - m_sourceRow.value(row);
+    int end = sourceModel()->rowCount() - m_sourceRow.value(lastRow);
+    sourceModel()->removeRows(start, end - start + 1);
+    endRemoveRows();
+    connect(sourceModel(), SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
+                this, SLOT(sourceRowsRemoved(const QModelIndex &, int, int)));
+    m_loaded = false;
+    if (oldCount - count != rowCount())
+        reset();
+    return true;
+}
+
+HistoryCompletionModel::HistoryCompletionModel(QObject *parent)
+    : QAbstractProxyModel(parent)
+{
+}
+
+QVariant HistoryCompletionModel::data(const QModelIndex &index, int role) const
+{
+    if (sourceModel()
+        && (role == Qt::EditRole || role == Qt::DisplayRole)
+        && index.isValid()) {
+        QModelIndex idx = mapToSource(index);
+        idx = idx.sibling(idx.row(), 1);
+        QString urlString = idx.data(HistoryModel::UrlStringRole).toString();
+        if (index.row() % 2) {
+            QUrl url = urlString;
+            QString s = url.toString(QUrl::RemoveScheme
+                                     | QUrl::RemoveUserInfo
+                                     | QUrl::StripTrailingSlash);
+            return s.mid(2);  // strip // from the front
+        }
+        return urlString;
+    }
+    return QAbstractProxyModel::data(index, role);
+}
+
+int HistoryCompletionModel::rowCount(const QModelIndex &parent) const
+{
+    return (parent.isValid() || !sourceModel()) ? 0 : sourceModel()->rowCount(parent) * 2;
+}
+
+int HistoryCompletionModel::columnCount(const QModelIndex &parent) const
+{
+    return (parent.isValid()) ? 0 : 1;
+}
+
+QModelIndex HistoryCompletionModel::mapFromSource(const QModelIndex &sourceIndex) const
+{
+    int row = sourceIndex.row() * 2;
+    return index(row, sourceIndex.column());
+}
+
+QModelIndex HistoryCompletionModel::mapToSource(const QModelIndex &proxyIndex) const
+{
+    if (!sourceModel())
+        return QModelIndex();
+    int row = proxyIndex.row() / 2;
+    return sourceModel()->index(row, proxyIndex.column());
+}
+
+QModelIndex HistoryCompletionModel::index(int row, int column, const QModelIndex &parent) const
+{
+    if (row < 0 || row >= rowCount(parent)
+        || column < 0 || column >= columnCount(parent))
+        return QModelIndex();
+    return createIndex(row, column, 0);
+}
+
+QModelIndex HistoryCompletionModel::parent(const QModelIndex &) const
+{
+    return QModelIndex();
+}
+
+void HistoryCompletionModel::setSourceModel(QAbstractItemModel *newSourceModel)
+{
+    if (sourceModel()) {
+        disconnect(sourceModel(), SIGNAL(modelReset()), this, SLOT(sourceReset()));
+        disconnect(sourceModel(), SIGNAL(rowsInserted(const QModelIndex &, int, int)),
+                this, SLOT(sourceReset()));
+        disconnect(sourceModel(), SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
+                this, SLOT(sourceReset()));
+    }
+
+    QAbstractProxyModel::setSourceModel(newSourceModel);
+
+    if (newSourceModel) {
+        connect(newSourceModel, SIGNAL(modelReset()), this, SLOT(sourceReset()));
+        connect(sourceModel(), SIGNAL(rowsInserted(const QModelIndex &, int, int)),
+                this, SLOT(sourceReset()));
+        connect(sourceModel(), SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
+                this, SLOT(sourceReset()));
+    }
+
+    reset();
+}
+
+void HistoryCompletionModel::sourceReset()
+{
+    reset();
+}
+
+HistoryTreeModel::HistoryTreeModel(QAbstractItemModel *sourceModel, QObject *parent)
+    : QAbstractProxyModel(parent)
+{
+    setSourceModel(sourceModel);
+}
+
+QVariant HistoryTreeModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    return sourceModel()->headerData(section, orientation, role);
+}
+
+QVariant HistoryTreeModel::data(const QModelIndex &index, int role) const
+{
+    if ((role == Qt::EditRole || role == Qt::DisplayRole)) {
+        int start = index.internalId();
+        if (start == 0) {
+            int offset = sourceDateRow(index.row());
+            if (index.column() == 0) {
+                QModelIndex idx = sourceModel()->index(offset, 0);
+                QDate date = idx.data(HistoryModel::DateRole).toDate();
+                if (date == QDate::currentDate())
+                    return tr("Earlier Today");
+                return date.toString(QLatin1String("dddd, MMMM d, yyyy"));
+            }
+            if (index.column() == 1) {
+                return tr("%1 items").arg(rowCount(index.sibling(index.row(), 0)));
+            }
+        }
+    }
+    if (role == Qt::DecorationRole && index.column() == 0 && !index.parent().isValid())
+        return QIcon(QLatin1String(":history.png"));
+    if (role == HistoryModel::DateRole && index.column() == 0 && index.internalId() == 0) {
+        int offset = sourceDateRow(index.row());
+        QModelIndex idx = sourceModel()->index(offset, 0);
+        return idx.data(HistoryModel::DateRole);
+    }
+
+    return QAbstractProxyModel::data(index, role);
+}
+
+int HistoryTreeModel::columnCount(const QModelIndex &parent) const
+{
+    return sourceModel()->columnCount(mapToSource(parent));
+}
+
+int HistoryTreeModel::rowCount(const QModelIndex &parent) const
+{
+    if ( parent.internalId() != 0
+        || parent.column() > 0
+        || !sourceModel())
+        return 0;
+
+    // row count OF dates
+    if (!parent.isValid()) {
+        if (!m_sourceRowCache.isEmpty())
+            return m_sourceRowCache.count();
+        QDate currentDate;
+        int rows = 0;
+        int totalRows = sourceModel()->rowCount();
+
+        for (int i = 0; i < totalRows; ++i) {
+            QDate rowDate = sourceModel()->index(i, 0).data(HistoryModel::DateRole).toDate();
+            if (rowDate != currentDate) {
+                m_sourceRowCache.append(i);
+                currentDate = rowDate;
+                ++rows;
+            }
+        }
+        Q_ASSERT(m_sourceRowCache.count() == rows);
+        return rows;
+    }
+
+    // row count FOR a date
+    int start = sourceDateRow(parent.row());
+    int end = sourceDateRow(parent.row() + 1);
+    return (end - start);
+}
+
+// Translate the top level date row into the offset where that date starts
+int HistoryTreeModel::sourceDateRow(int row) const
+{
+    if (row <= 0)
+        return 0;
+
+    if (m_sourceRowCache.isEmpty())
+        rowCount(QModelIndex());
+
+    if (row >= m_sourceRowCache.count()) {
+        if (!sourceModel())
+            return 0;
+        return sourceModel()->rowCount();
+    }
+    return m_sourceRowCache.at(row);
+}
+
+QModelIndex HistoryTreeModel::mapToSource(const QModelIndex &proxyIndex) const
+{
+    int offset = proxyIndex.internalId();
+    if (offset == 0)
+        return QModelIndex();
+    int startDateRow = sourceDateRow(offset - 1);
+    return sourceModel()->index(startDateRow + proxyIndex.row(), proxyIndex.column());
+}
+
+QModelIndex HistoryTreeModel::index(int row, int column, const QModelIndex &parent) const
+{
+    if (row < 0
+        || column < 0 || column >= columnCount(parent)
+        || parent.column() > 0)
+        return QModelIndex();
+
+    if (!parent.isValid())
+        return createIndex(row, column, 0);
+    return createIndex(row, column, parent.row() + 1);
+}
+
+QModelIndex HistoryTreeModel::parent(const QModelIndex &index) const
+{
+    int offset = index.internalId();
+    if (offset == 0 || !index.isValid())
+        return QModelIndex();
+    return createIndex(offset - 1, 0, 0);
+}
+
+bool HistoryTreeModel::hasChildren(const QModelIndex &parent) const
+{
+    QModelIndex grandparent = parent.parent();
+    if (!grandparent.isValid())
+        return true;
+    return false;
+}
+
+Qt::ItemFlags HistoryTreeModel::flags(const QModelIndex &index) const
+{
+    if (!index.isValid())
+        return Qt::NoItemFlags;
+    return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled;
+}
+
+bool HistoryTreeModel::removeRows(int row, int count, const QModelIndex &parent)
+{
+    if (row < 0 || count <= 0 || row + count > rowCount(parent))
+        return false;
+
+    if (parent.isValid()) {
+        // removing pages
+        int offset = sourceDateRow(parent.row());
+        return sourceModel()->removeRows(offset + row, count);
+    } else {
+        // removing whole dates
+        for (int i = row + count - 1; i >= row; --i) {
+            QModelIndex dateParent = index(i, 0);
+            int offset = sourceDateRow(dateParent.row());
+            if (!sourceModel()->removeRows(offset, rowCount(dateParent)))
+                return false;
+        }
+    }
+    return true;
+}
+
+void HistoryTreeModel::setSourceModel(QAbstractItemModel *newSourceModel)
+{
+    if (sourceModel()) {
+        disconnect(sourceModel(), SIGNAL(modelReset()), this, SLOT(sourceReset()));
+        disconnect(sourceModel(), SIGNAL(layoutChanged()), this, SLOT(sourceReset()));
+        disconnect(sourceModel(), SIGNAL(rowsInserted(const QModelIndex &, int, int)),
+                this, SLOT(sourceRowsInserted(const QModelIndex &, int, int)));
+        disconnect(sourceModel(), SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
+                this, SLOT(sourceRowsRemoved(const QModelIndex &, int, int)));
+    }
+
+    QAbstractProxyModel::setSourceModel(newSourceModel);
+
+    if (newSourceModel) {
+        connect(sourceModel(), SIGNAL(modelReset()), this, SLOT(sourceReset()));
+        connect(sourceModel(), SIGNAL(layoutChanged()), this, SLOT(sourceReset()));
+        connect(sourceModel(), SIGNAL(rowsInserted(const QModelIndex &, int, int)),
+                this, SLOT(sourceRowsInserted(const QModelIndex &, int, int)));
+        connect(sourceModel(), SIGNAL(rowsRemoved(const QModelIndex &, int, int)),
+                this, SLOT(sourceRowsRemoved(const QModelIndex &, int, int)));
+    }
+
+    reset();
+}
+
+void HistoryTreeModel::sourceReset()
+{
+    m_sourceRowCache.clear();
+    reset();
+}
+
+void HistoryTreeModel::sourceRowsInserted(const QModelIndex &parent, int start, int end)
+{
+    Q_UNUSED(parent); // Avoid warnings when compiling release
+    Q_ASSERT(!parent.isValid());
+    if (start != 0 || start != end) {
+        m_sourceRowCache.clear();
+        reset();
+        return;
+    }
+
+    m_sourceRowCache.clear();
+    QModelIndex treeIndex = mapFromSource(sourceModel()->index(start, 0));
+    QModelIndex treeParent = treeIndex.parent();
+    if (rowCount(treeParent) == 1) {
+        beginInsertRows(QModelIndex(), 0, 0);
+        endInsertRows();
+    } else {
+        beginInsertRows(treeParent, treeIndex.row(), treeIndex.row());
+        endInsertRows();
+    }
+}
+
+QModelIndex HistoryTreeModel::mapFromSource(const QModelIndex &sourceIndex) const
+{
+    if (!sourceIndex.isValid())
+        return QModelIndex();
+
+    if (m_sourceRowCache.isEmpty())
+        rowCount(QModelIndex());
+
+    QList<int>::iterator it;
+    it = qLowerBound(m_sourceRowCache.begin(), m_sourceRowCache.end(), sourceIndex.row());
+    if (*it != sourceIndex.row())
+        --it;
+    int dateRow = qMax(0, it - m_sourceRowCache.begin());
+    int row = sourceIndex.row() - m_sourceRowCache.at(dateRow);
+    return createIndex(row, sourceIndex.column(), dateRow + 1);
+}
+
+void HistoryTreeModel::sourceRowsRemoved(const QModelIndex &parent, int start, int end)
+{
+    Q_UNUSED(parent); // Avoid warnings when compiling release
+    Q_ASSERT(!parent.isValid());
+    if (m_sourceRowCache.isEmpty())
+        return;
+    for (int i = end; i >= start;) {
+        QList<int>::iterator it;
+        it = qLowerBound(m_sourceRowCache.begin(), m_sourceRowCache.end(), i);
+        // playing it safe
+        if (it == m_sourceRowCache.end()) {
+            m_sourceRowCache.clear();
+            reset();
+            return;
+        }
+
+        if (*it != i)
+            --it;
+        int row = qMax(0, it - m_sourceRowCache.begin());
+        int offset = m_sourceRowCache[row];
+        QModelIndex dateParent = index(row, 0);
+        // If we can remove all the rows in the date do that and skip over them
+        int rc = rowCount(dateParent);
+        if (i - rc + 1 == offset && start <= i - rc + 1) {
+            beginRemoveRows(QModelIndex(), row, row);
+            m_sourceRowCache.removeAt(row);
+            i -= rc + 1;
+        } else {
+            beginRemoveRows(dateParent, i - offset, i - offset);
+            ++row;
+            --i;
+        }
+        for (int j = row; j < m_sourceRowCache.count(); ++j)
+            --m_sourceRowCache[j];
+        endRemoveRows();
+    }
+}
+
diff --git a/examples/gestures/browser/history.h b/examples/gestures/browser/history.h
new file mode 100644
index 0000000..34b7c10
--- /dev/null
+++ b/examples/gestures/browser/history.h
@@ -0,0 +1,350 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef HISTORY_H
+#define HISTORY_H
+
+#include "modelmenu.h"
+
+#include <QtCore/QDateTime>
+#include <QtCore/QHash>
+#include <QtCore/QObject>
+#include <QtCore/QTimer>
+#include <QtCore/QUrl>
+
+#include <QtGui/QSortFilterProxyModel>
+
+#include <QWebHistoryInterface>
+
+class HistoryItem
+{
+public:
+    HistoryItem() {}
+    HistoryItem(const QString &u,
+                const QDateTime &d = QDateTime(), const QString &t = QString())
+        : title(t), url(u), dateTime(d) {}
+
+    inline bool operator==(const HistoryItem &other) const
+        { return other.title == title
+          && other.url == url && other.dateTime == dateTime; }
+
+    // history is sorted in reverse
+    inline bool operator <(const HistoryItem &other) const
+        { return dateTime > other.dateTime; }
+
+    QString title;
+    QString url;
+    QDateTime dateTime;
+};
+
+class AutoSaver;
+class HistoryModel;
+class HistoryFilterModel;
+class HistoryTreeModel;
+class HistoryManager : public QWebHistoryInterface
+{
+    Q_OBJECT
+    Q_PROPERTY(int historyLimit READ historyLimit WRITE setHistoryLimit)
+
+signals:
+    void historyReset();
+    void entryAdded(const HistoryItem &item);
+    void entryRemoved(const HistoryItem &item);
+    void entryUpdated(int offset);
+
+public:
+    HistoryManager(QObject *parent = 0);
+    ~HistoryManager();
+
+    bool historyContains(const QString &url) const;
+    void addHistoryEntry(const QString &url);
+
+    void updateHistoryItem(const QUrl &url, const QString &title);
+
+    int historyLimit() const;
+    void setHistoryLimit(int limit);
+
+    QList<HistoryItem> history() const;
+    void setHistory(const QList<HistoryItem> &history, bool loadedAndSorted = false);
+
+    // History manager keeps around these models for use by the completer and other classes
+    HistoryModel *historyModel() const;
+    HistoryFilterModel *historyFilterModel() const;
+    HistoryTreeModel *historyTreeModel() const;
+
+public slots:
+    void clear();
+    void loadSettings();
+
+private slots:
+    void save();
+    void checkForExpired();
+
+protected:
+    void addHistoryItem(const HistoryItem &item);
+
+private:
+    void load();
+
+    AutoSaver *m_saveTimer;
+    int m_historyLimit;
+    QTimer m_expiredTimer;
+    QList<HistoryItem> m_history;
+    QString m_lastSavedUrl;
+
+    HistoryModel *m_historyModel;
+    HistoryFilterModel *m_historyFilterModel;
+    HistoryTreeModel *m_historyTreeModel;
+};
+
+class HistoryModel : public QAbstractTableModel
+{
+    Q_OBJECT
+
+public slots:
+    void historyReset();
+    void entryAdded();
+    void entryUpdated(int offset);
+
+public:
+    enum Roles {
+        DateRole = Qt::UserRole + 1,
+        DateTimeRole = Qt::UserRole + 2,
+        UrlRole = Qt::UserRole + 3,
+        UrlStringRole = Qt::UserRole + 4
+    };
+
+    HistoryModel(HistoryManager *history, QObject *parent = 0);
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
+
+private:
+    HistoryManager *m_history;
+};
+
+/*!
+    Proxy model that will remove any duplicate entries.
+    Both m_sourceRow and m_historyHash store their offsets not from
+    the front of the list, but as offsets from the back.
+  */
+class HistoryFilterModel : public QAbstractProxyModel
+{
+    Q_OBJECT
+
+public:
+    HistoryFilterModel(QAbstractItemModel *sourceModel, QObject *parent = 0);
+
+    inline bool historyContains(const QString &url) const
+        { load(); return m_historyHash.contains(url); }
+    int historyLocation(const QString &url) const;
+
+    QModelIndex mapFromSource(const QModelIndex &sourceIndex) const;
+    QModelIndex mapToSource(const QModelIndex &proxyIndex) const;
+    void setSourceModel(QAbstractItemModel *sourceModel);
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const;
+    QModelIndex index(int, int, const QModelIndex& = QModelIndex()) const;
+    QModelIndex parent(const QModelIndex& index= QModelIndex()) const;
+    bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+
+private slots:
+    void sourceReset();
+    void sourceDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);
+    void sourceRowsInserted(const QModelIndex &parent, int start, int end);
+    void sourceRowsRemoved(const QModelIndex &, int, int);
+
+private:
+    void load() const;
+
+    mutable QList<int> m_sourceRow;
+    mutable QHash<QString, int> m_historyHash;
+    mutable bool m_loaded;
+};
+
+/*
+    The history menu
+    - Removes the first twenty entries and puts them as children of the top level.
+    - If there are less then twenty entries then the first folder is also removed.
+
+    The mapping is done by knowing that HistoryTreeModel is over a table
+    We store that row offset in our index's private data.
+*/
+class HistoryMenuModel : public QAbstractProxyModel
+{
+    Q_OBJECT
+
+public:
+    HistoryMenuModel(HistoryTreeModel *sourceModel, QObject *parent = 0);
+    int columnCount(const QModelIndex &parent) const;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    QModelIndex mapFromSource(const QModelIndex & sourceIndex) const;
+    QModelIndex mapToSource(const QModelIndex & proxyIndex) const;
+    QModelIndex index(int, int, const QModelIndex &parent = QModelIndex()) const;
+    QModelIndex parent(const QModelIndex &index = QModelIndex()) const;
+
+    int bumpedRows() const;
+
+private:
+    HistoryTreeModel *m_treeModel;
+};
+
+// Menu that is dynamically populated from the history
+class HistoryMenu : public ModelMenu
+{
+    Q_OBJECT
+
+signals:
+    void openUrl(const QUrl &url);
+
+public:
+     HistoryMenu(QWidget *parent = 0);
+     void setInitialActions(QList<QAction*> actions);
+
+protected:
+    bool prePopulated();
+    void postPopulated();
+
+private slots:
+    void activated(const QModelIndex &index);
+    void showHistoryDialog();
+
+private:
+    HistoryManager *m_history;
+    HistoryMenuModel *m_historyMenuModel;
+    QList<QAction*> m_initialActions;
+};
+
+// proxy model for the history model that
+// exposes each url http://www.foo.com and it url starting at the host www.foo.com
+class HistoryCompletionModel : public QAbstractProxyModel
+{
+    Q_OBJECT
+
+public:
+    HistoryCompletionModel(QObject *parent = 0);
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const;
+    QModelIndex mapFromSource(const QModelIndex &sourceIndex) const;
+    QModelIndex mapToSource(const QModelIndex &proxyIndex) const;
+    QModelIndex index(int, int, const QModelIndex& = QModelIndex()) const;
+    QModelIndex parent(const QModelIndex& index= QModelIndex()) const;
+    void setSourceModel(QAbstractItemModel *sourceModel);
+
+private slots:
+    void sourceReset();
+
+};
+
+// proxy model for the history model that converts the list
+// into a tree, one top level node per day.
+// Used in the HistoryDialog.
+class HistoryTreeModel : public QAbstractProxyModel
+{
+    Q_OBJECT
+
+public:
+    HistoryTreeModel(QAbstractItemModel *sourceModel, QObject *parent = 0);
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    int columnCount(const QModelIndex &parent) const;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    QModelIndex mapFromSource(const QModelIndex &sourceIndex) const;
+    QModelIndex mapToSource(const QModelIndex &proxyIndex) const;
+    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
+    QModelIndex parent(const QModelIndex &index= QModelIndex()) const;
+    bool hasChildren(const QModelIndex &parent = QModelIndex()) const;
+    Qt::ItemFlags flags(const QModelIndex &index) const;
+    bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+
+    void setSourceModel(QAbstractItemModel *sourceModel);
+
+private slots:
+    void sourceReset();
+    void sourceRowsInserted(const QModelIndex &parent, int start, int end);
+    void sourceRowsRemoved(const QModelIndex &parent, int start, int end);
+
+private:
+    int sourceDateRow(int row) const;
+    mutable QList<int> m_sourceRowCache;
+
+};
+
+// A modified QSortFilterProxyModel that always accepts the root nodes in the tree
+// so filtering is only done on the children.
+// Used in the HistoryDialog
+class TreeProxyModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+
+public:
+    TreeProxyModel(QObject *parent = 0);
+
+protected:
+    bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const;
+};
+
+#include "ui_history.h"
+
+class HistoryDialog : public QDialog, public Ui_HistoryDialog
+{
+    Q_OBJECT
+
+signals:
+    void openUrl(const QUrl &url);
+
+public:
+    HistoryDialog(QWidget *parent = 0, HistoryManager *history = 0);
+
+private slots:
+    void customContextMenuRequested(const QPoint &pos);
+    void open();
+    void copy();
+
+};
+
+#endif // HISTORY_H
+
diff --git a/examples/gestures/browser/history.ui b/examples/gestures/browser/history.ui
new file mode 100644
index 0000000..0944940
--- /dev/null
+++ b/examples/gestures/browser/history.ui
@@ -0,0 +1,106 @@
+<ui version="4.0" >
+ <class>HistoryDialog</class>
+ <widget class="QDialog" name="HistoryDialog" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>758</width>
+    <height>450</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>History</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout" >
+   <item row="0" column="0" >
+    <spacer>
+     <property name="orientation" >
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="sizeHint" stdset="0" >
+      <size>
+       <width>252</width>
+       <height>20</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="0" column="1" >
+    <widget class="SearchLineEdit" name="search" />
+   </item>
+   <item row="1" column="0" colspan="2" >
+    <widget class="EditTreeView" name="tree" />
+   </item>
+   <item row="2" column="0" colspan="2" >
+    <layout class="QHBoxLayout" >
+     <item>
+      <widget class="QPushButton" name="removeButton" >
+       <property name="text" >
+        <string>&amp;Remove</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="removeAllButton" >
+       <property name="text" >
+        <string>Remove &amp;All</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer>
+       <property name="orientation" >
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0" >
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QDialogButtonBox" name="buttonBox" >
+       <property name="standardButtons" >
+        <set>QDialogButtonBox::Ok</set>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>SearchLineEdit</class>
+   <extends>QLineEdit</extends>
+   <header>searchlineedit.h</header>
+  </customwidget>
+  <customwidget>
+   <class>EditTreeView</class>
+   <extends>QTreeView</extends>
+   <header>edittreeview.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>HistoryDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel" >
+     <x>472</x>
+     <y>329</y>
+    </hint>
+    <hint type="destinationlabel" >
+     <x>461</x>
+     <y>356</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/examples/gestures/browser/main.cpp b/examples/gestures/browser/main.cpp
new file mode 100644
index 0000000..d551ab4
--- /dev/null
+++ b/examples/gestures/browser/main.cpp
@@ -0,0 +1,53 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "browserapplication.h"
+
+int main(int argc, char **argv)
+{
+    Q_INIT_RESOURCE(data);
+    BrowserApplication application(argc, argv);
+    if (!application.isTheOnlyBrowser())
+        return 0;
+    application.newMainWindow();
+    return application.exec();
+}
+
diff --git a/examples/gestures/browser/modelmenu.cpp b/examples/gestures/browser/modelmenu.cpp
new file mode 100644
index 0000000..980b62b
--- /dev/null
+++ b/examples/gestures/browser/modelmenu.cpp
@@ -0,0 +1,227 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "modelmenu.h"
+
+#include <QtCore/QAbstractItemModel>
+#include <qdebug.h>
+
+ModelMenu::ModelMenu(QWidget * parent)
+    : QMenu(parent)
+    , m_maxRows(7)
+    , m_firstSeparator(-1)
+    , m_maxWidth(-1)
+    , m_hoverRole(0)
+    , m_separatorRole(0)
+    , m_model(0)
+{
+    connect(this, SIGNAL(aboutToShow()), this, SLOT(aboutToShow()));
+}
+
+bool ModelMenu::prePopulated()
+{
+    return false;
+}
+
+void ModelMenu::postPopulated()
+{
+}
+
+void ModelMenu::setModel(QAbstractItemModel *model)
+{
+    m_model = model;
+}
+
+QAbstractItemModel *ModelMenu::model() const
+{
+    return m_model;
+}
+
+void ModelMenu::setMaxRows(int max)
+{
+    m_maxRows = max;
+}
+
+int ModelMenu::maxRows() const
+{
+    return m_maxRows;
+}
+
+void ModelMenu::setFirstSeparator(int offset)
+{
+    m_firstSeparator = offset;
+}
+
+int ModelMenu::firstSeparator() const
+{
+    return m_firstSeparator;
+}
+
+void ModelMenu::setRootIndex(const QModelIndex &index)
+{
+    m_root = index;
+}
+
+QModelIndex ModelMenu::rootIndex() const
+{
+    return m_root;
+}
+
+void ModelMenu::setHoverRole(int role)
+{
+    m_hoverRole = role;
+}
+
+int ModelMenu::hoverRole() const
+{
+    return m_hoverRole;
+}
+
+void ModelMenu::setSeparatorRole(int role)
+{
+    m_separatorRole = role;
+}
+
+int ModelMenu::separatorRole() const
+{
+    return m_separatorRole;
+}
+
+Q_DECLARE_METATYPE(QModelIndex)
+void ModelMenu::aboutToShow()
+{
+    if (QMenu *menu = qobject_cast<QMenu*>(sender())) {
+        QVariant v = menu->menuAction()->data();
+        if (v.canConvert<QModelIndex>()) {
+            QModelIndex idx = qvariant_cast<QModelIndex>(v);
+            createMenu(idx, -1, menu, menu);
+            disconnect(menu, SIGNAL(aboutToShow()), this, SLOT(aboutToShow()));
+            return;
+        }
+    }
+
+    clear();
+    if (prePopulated())
+        addSeparator();
+    int max = m_maxRows;
+    if (max != -1)
+        max += m_firstSeparator;
+    createMenu(m_root, max, this, this);
+    postPopulated();
+}
+
+void ModelMenu::createMenu(const QModelIndex &parent, int max, QMenu *parentMenu, QMenu *menu)
+{
+    if (!menu) {
+        QString title = parent.data().toString();
+        menu = new QMenu(title, this);
+        QIcon icon = qvariant_cast<QIcon>(parent.data(Qt::DecorationRole));
+        menu->setIcon(icon);
+        parentMenu->addMenu(menu);
+        QVariant v;
+        v.setValue(parent);
+        menu->menuAction()->setData(v);
+        connect(menu, SIGNAL(aboutToShow()), this, SLOT(aboutToShow()));
+        return;
+    }
+
+    int end = m_model->rowCount(parent);
+    if (max != -1)
+        end = qMin(max, end);
+
+    connect(menu, SIGNAL(triggered(QAction*)), this, SLOT(triggered(QAction*)));
+    connect(menu, SIGNAL(hovered(QAction*)), this, SLOT(hovered(QAction*)));
+
+    for (int i = 0; i < end; ++i) {
+        QModelIndex idx = m_model->index(i, 0, parent);
+        if (m_model->hasChildren(idx)) {
+            createMenu(idx, -1, menu);
+        } else {
+            if (m_separatorRole != 0
+                && idx.data(m_separatorRole).toBool())
+                addSeparator();
+            else
+                menu->addAction(makeAction(idx));
+        }
+        if (menu == this && i == m_firstSeparator - 1)
+            addSeparator();
+    }
+}
+
+QAction *ModelMenu::makeAction(const QModelIndex &index)
+{
+    QIcon icon = qvariant_cast<QIcon>(index.data(Qt::DecorationRole));
+    QAction *action = makeAction(icon, index.data().toString(), this);
+    QVariant v;
+    v.setValue(index);
+    action->setData(v);
+    return action;
+}
+
+QAction *ModelMenu::makeAction(const QIcon &icon, const QString &text, QObject *parent)
+{
+    QFontMetrics fm(font());
+    if (-1 == m_maxWidth)
+        m_maxWidth = fm.width(QLatin1Char('m')) * 30;
+    QString smallText = fm.elidedText(text, Qt::ElideMiddle, m_maxWidth);
+    return new QAction(icon, smallText, parent);
+}
+
+void ModelMenu::triggered(QAction *action)
+{
+    QVariant v = action->data();
+    if (v.canConvert<QModelIndex>()) {
+        QModelIndex idx = qvariant_cast<QModelIndex>(v);
+        emit activated(idx);
+    }
+}
+
+void ModelMenu::hovered(QAction *action)
+{
+    QVariant v = action->data();
+    if (v.canConvert<QModelIndex>()) {
+        QModelIndex idx = qvariant_cast<QModelIndex>(v);
+        QString hoveredString = idx.data(m_hoverRole).toString();
+        if (!hoveredString.isEmpty())
+            emit hovered(hoveredString);
+    }
+}
+
diff --git a/examples/gestures/browser/modelmenu.h b/examples/gestures/browser/modelmenu.h
new file mode 100644
index 0000000..b888f05
--- /dev/null
+++ b/examples/gestures/browser/modelmenu.h
@@ -0,0 +1,105 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef MODELMENU_H
+#define MODELMENU_H
+
+#include <QtGui/QMenu>
+#include <QtCore/QAbstractItemModel>
+
+// A QMenu that is dynamically populated from a QAbstractItemModel
+class ModelMenu : public QMenu
+{
+    Q_OBJECT
+
+signals:
+    void activated(const QModelIndex &index);
+    void hovered(const QString &text);
+
+public:
+    ModelMenu(QWidget *parent = 0);
+
+    void setModel(QAbstractItemModel *model);
+    QAbstractItemModel *model() const;
+
+    void setMaxRows(int max);
+    int maxRows() const;
+
+    void setFirstSeparator(int offset);
+    int firstSeparator() const;
+
+    void setRootIndex(const QModelIndex &index);
+    QModelIndex rootIndex() const;
+
+    void setHoverRole(int role);
+    int hoverRole() const;
+
+    void setSeparatorRole(int role);
+    int separatorRole() const;
+
+    QAction *makeAction(const QIcon &icon, const QString &text, QObject *parent);
+
+protected:
+    // add any actions before the tree, return true if any actions are added.
+    virtual bool prePopulated();
+    // add any actions after the tree
+    virtual void postPopulated();
+    // put all of the children of parent into menu up to max
+    void createMenu(const QModelIndex &parent, int max, QMenu *parentMenu = 0, QMenu *menu = 0);
+
+private slots:
+    void aboutToShow();
+    void triggered(QAction *action);
+    void hovered(QAction *action);
+
+private:
+    QAction *makeAction(const QModelIndex &index);
+    int m_maxRows;
+    int m_firstSeparator;
+    int m_maxWidth;
+    int m_hoverRole;
+    int m_separatorRole;
+    QAbstractItemModel *m_model;
+    QPersistentModelIndex m_root;
+};
+
+#endif // MODELMENU_H
+
diff --git a/examples/gestures/browser/networkaccessmanager.cpp b/examples/gestures/browser/networkaccessmanager.cpp
new file mode 100644
index 0000000..f777937
--- /dev/null
+++ b/examples/gestures/browser/networkaccessmanager.cpp
@@ -0,0 +1,171 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "networkaccessmanager.h"
+
+#include "browserapplication.h"
+#include "browsermainwindow.h"
+#include "ui_passworddialog.h"
+#include "ui_proxy.h"
+
+#include <QtCore/QSettings>
+
+#include <QtGui/QDesktopServices>
+#include <QtGui/QDialog>
+#include <QtGui/QMessageBox>
+#include <QtGui/QStyle>
+#include <QtGui/QTextDocument>
+
+#include <QtNetwork/QAuthenticator>
+#include <QtNetwork/QNetworkDiskCache>
+#include <QtNetwork/QNetworkProxy>
+#include <QtNetwork/QNetworkReply>
+#include <QtNetwork/QSslError>
+
+NetworkAccessManager::NetworkAccessManager(QObject *parent)
+    : QNetworkAccessManager(parent)
+{
+    connect(this, SIGNAL(authenticationRequired(QNetworkReply*, QAuthenticator*)),
+            SLOT(authenticationRequired(QNetworkReply*,QAuthenticator*)));
+    connect(this, SIGNAL(proxyAuthenticationRequired(const QNetworkProxy&, QAuthenticator*)),
+            SLOT(proxyAuthenticationRequired(const QNetworkProxy&, QAuthenticator*)));
+#ifndef QT_NO_OPENSSL
+    connect(this, SIGNAL(sslErrors(QNetworkReply*, const QList<QSslError>&)),
+            SLOT(sslErrors(QNetworkReply*, const QList<QSslError>&)));
+#endif
+    loadSettings();
+
+    QNetworkDiskCache *diskCache = new QNetworkDiskCache(this);
+    QString location = QDesktopServices::storageLocation(QDesktopServices::CacheLocation);
+    diskCache->setCacheDirectory(location);
+    setCache(diskCache);
+}
+
+void NetworkAccessManager::loadSettings()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("proxy"));
+    QNetworkProxy proxy;
+    if (settings.value(QLatin1String("enabled"), false).toBool()) {
+        if (settings.value(QLatin1String("type"), 0).toInt() == 0)
+            proxy = QNetworkProxy::Socks5Proxy;
+        else
+            proxy = QNetworkProxy::HttpProxy;
+        proxy.setHostName(settings.value(QLatin1String("hostName")).toString());
+        proxy.setPort(settings.value(QLatin1String("port"), 1080).toInt());
+        proxy.setUser(settings.value(QLatin1String("userName")).toString());
+        proxy.setPassword(settings.value(QLatin1String("password")).toString());
+    }
+    setProxy(proxy);
+}
+
+void NetworkAccessManager::authenticationRequired(QNetworkReply *reply, QAuthenticator *auth)
+{
+    BrowserMainWindow *mainWindow = BrowserApplication::instance()->mainWindow();
+
+    QDialog dialog(mainWindow);
+    dialog.setWindowFlags(Qt::Sheet);
+
+    Ui::PasswordDialog passwordDialog;
+    passwordDialog.setupUi(&dialog);
+
+    passwordDialog.iconLabel->setText(QString());
+    passwordDialog.iconLabel->setPixmap(mainWindow->style()->standardIcon(QStyle::SP_MessageBoxQuestion, 0, mainWindow).pixmap(32, 32));
+
+    QString introMessage = tr("<qt>Enter username and password for \"%1\" at %2</qt>");
+    introMessage = introMessage.arg(Qt::escape(reply->url().toString())).arg(Qt::escape(reply->url().toString()));
+    passwordDialog.introLabel->setText(introMessage);
+    passwordDialog.introLabel->setWordWrap(true);
+
+    if (dialog.exec() == QDialog::Accepted) {
+        auth->setUser(passwordDialog.userNameLineEdit->text());
+        auth->setPassword(passwordDialog.passwordLineEdit->text());
+    }
+}
+
+void NetworkAccessManager::proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *auth)
+{
+    BrowserMainWindow *mainWindow = BrowserApplication::instance()->mainWindow();
+
+    QDialog dialog(mainWindow);
+    dialog.setWindowFlags(Qt::Sheet);
+
+    Ui::ProxyDialog proxyDialog;
+    proxyDialog.setupUi(&dialog);
+
+    proxyDialog.iconLabel->setText(QString());
+    proxyDialog.iconLabel->setPixmap(mainWindow->style()->standardIcon(QStyle::SP_MessageBoxQuestion, 0, mainWindow).pixmap(32, 32));
+
+    QString introMessage = tr("<qt>Connect to proxy \"%1\" using:</qt>");
+    introMessage = introMessage.arg(Qt::escape(proxy.hostName()));
+    proxyDialog.introLabel->setText(introMessage);
+    proxyDialog.introLabel->setWordWrap(true);
+
+    if (dialog.exec() == QDialog::Accepted) {
+        auth->setUser(proxyDialog.userNameLineEdit->text());
+        auth->setPassword(proxyDialog.passwordLineEdit->text());
+    }
+}
+
+#ifndef QT_NO_OPENSSL
+void NetworkAccessManager::sslErrors(QNetworkReply *reply, const QList<QSslError> &error)
+{
+    // check if SSL certificate has been trusted already
+    QString replyHost = reply->url().host() + ":" + reply->url().port();
+    if(! sslTrustedHostList.contains(replyHost)) {
+        BrowserMainWindow *mainWindow = BrowserApplication::instance()->mainWindow();
+
+        QStringList errorStrings;
+        for (int i = 0; i < error.count(); ++i)
+            errorStrings += error.at(i).errorString();
+        QString errors = errorStrings.join(QLatin1String("\n"));
+        int ret = QMessageBox::warning(mainWindow, QCoreApplication::applicationName(),
+                tr("SSL Errors:\n\n%1\n\n%2\n\n"
+                        "Do you want to ignore these errors for this host?").arg(reply->url().toString()).arg(errors),
+                        QMessageBox::Yes | QMessageBox::No,
+                        QMessageBox::No);
+        if (ret == QMessageBox::Yes) {
+            reply->ignoreSslErrors();
+            sslTrustedHostList.append(replyHost);
+        }
+    }
+}
+#endif
diff --git a/examples/gestures/browser/networkaccessmanager.h b/examples/gestures/browser/networkaccessmanager.h
new file mode 100644
index 0000000..6c938ac
--- /dev/null
+++ b/examples/gestures/browser/networkaccessmanager.h
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef NETWORKACCESSMANAGER_H
+#define NETWORKACCESSMANAGER_H
+
+#include <QtNetwork/QNetworkAccessManager>
+
+class NetworkAccessManager : public QNetworkAccessManager
+{
+    Q_OBJECT
+
+public:
+    NetworkAccessManager(QObject *parent = 0);
+
+private:
+    QList<QString> sslTrustedHostList;
+
+public slots:
+    void loadSettings();
+
+private slots:
+    void authenticationRequired(QNetworkReply *reply, QAuthenticator *auth);
+    void proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *auth);
+#ifndef QT_NO_OPENSSL
+    void sslErrors(QNetworkReply *reply, const QList<QSslError> &error);
+#endif
+};
+
+#endif // NETWORKACCESSMANAGER_H
diff --git a/examples/gestures/browser/passworddialog.ui b/examples/gestures/browser/passworddialog.ui
new file mode 100644
index 0000000..7c16658
--- /dev/null
+++ b/examples/gestures/browser/passworddialog.ui
@@ -0,0 +1,111 @@
+<ui version="4.0" >
+ <class>PasswordDialog</class>
+ <widget class="QDialog" name="PasswordDialog" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>399</width>
+    <height>148</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Authentication Required</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout" >
+   <item row="0" column="0" colspan="2" >
+    <layout class="QHBoxLayout" >
+     <item>
+      <widget class="QLabel" name="iconLabel" >
+       <property name="text" >
+        <string>DUMMY ICON</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="introLabel" >
+       <property name="sizePolicy" >
+        <sizepolicy vsizetype="MinimumExpanding" hsizetype="MinimumExpanding" >
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text" >
+        <string>INTRO TEXT DUMMY</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="1" column="0" >
+    <widget class="QLabel" name="label" >
+     <property name="text" >
+      <string>Username:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="1" >
+    <widget class="QLineEdit" name="userNameLineEdit" />
+   </item>
+   <item row="2" column="0" >
+    <widget class="QLabel" name="lblPassword" >
+     <property name="text" >
+      <string>Password:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="1" >
+    <widget class="QLineEdit" name="passwordLineEdit" >
+     <property name="echoMode" >
+      <enum>QLineEdit::Password</enum>
+     </property>
+    </widget>
+   </item>
+   <item row="3" 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>PasswordDialog</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>PasswordDialog</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/examples/gestures/browser/proxy.ui b/examples/gestures/browser/proxy.ui
new file mode 100644
index 0000000..62a8be6
--- /dev/null
+++ b/examples/gestures/browser/proxy.ui
@@ -0,0 +1,104 @@
+<ui version="4.0" >
+ <class>ProxyDialog</class>
+ <widget class="QDialog" name="ProxyDialog" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>369</width>
+    <height>144</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Proxy Authentication</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout" >
+   <item row="0" column="0" >
+    <widget class="QLabel" name="iconLabel" >
+     <property name="text" >
+      <string>ICON</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="1" colspan="2" >
+    <widget class="QLabel" name="introLabel" >
+     <property name="text" >
+      <string>Connect to proxy</string>
+     </property>
+     <property name="wordWrap" >
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0" colspan="2" >
+    <widget class="QLabel" name="usernameLabel" >
+     <property name="text" >
+      <string>Username:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="2" >
+    <widget class="QLineEdit" name="userNameLineEdit" />
+   </item>
+   <item row="2" column="0" colspan="2" >
+    <widget class="QLabel" name="passwordLabel" >
+     <property name="text" >
+      <string>Password:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="2" column="2" >
+    <widget class="QLineEdit" name="passwordLineEdit" >
+     <property name="echoMode" >
+      <enum>QLineEdit::Password</enum>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="0" colspan="3" >
+    <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>ProxyDialog</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>ProxyDialog</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/examples/gestures/browser/searchlineedit.cpp b/examples/gestures/browser/searchlineedit.cpp
new file mode 100644
index 0000000..09d80fb
--- /dev/null
+++ b/examples/gestures/browser/searchlineedit.cpp
@@ -0,0 +1,238 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "searchlineedit.h"
+
+#include <QtGui/QPainter>
+#include <QtGui/QMouseEvent>
+#include <QtGui/QMenu>
+#include <QtGui/QStyle>
+#include <QtGui/QStyleOptionFrameV2>
+
+ClearButton::ClearButton(QWidget *parent)
+  : QAbstractButton(parent)
+{
+    setCursor(Qt::ArrowCursor);
+    setToolTip(tr("Clear"));
+    setVisible(false);
+    setFocusPolicy(Qt::NoFocus);
+}
+
+void ClearButton::paintEvent(QPaintEvent *event)
+{
+    Q_UNUSED(event);
+    QPainter painter(this);
+    int height = this->height();
+
+    painter.setRenderHint(QPainter::Antialiasing, true);
+    QColor color = palette().color(QPalette::Mid);
+    painter.setBrush(isDown()
+                     ? palette().color(QPalette::Dark)
+                     : palette().color(QPalette::Mid));
+    painter.setPen(painter.brush().color());
+    int size = width();
+    int offset = size / 5;
+    int radius = size - offset * 2;
+    painter.drawEllipse(offset, offset, radius, radius);
+
+    painter.setPen(palette().color(QPalette::Base));
+    int border = offset * 2;
+    painter.drawLine(border, border, width() - border, height - border);
+    painter.drawLine(border, height - border, width() - border, border);
+}
+
+void ClearButton::textChanged(const QString &text)
+{
+    setVisible(!text.isEmpty());
+}
+
+/*
+    Search icon on the left hand side of the search widget
+    When a menu is set a down arrow appears
+ */
+class SearchButton : public QAbstractButton {
+public:
+    SearchButton(QWidget *parent = 0);
+    void paintEvent(QPaintEvent *event);
+    QMenu *m_menu;
+
+protected:
+    void mousePressEvent(QMouseEvent *event);
+};
+
+SearchButton::SearchButton(QWidget *parent)
+  : QAbstractButton(parent),
+    m_menu(0)
+{
+    setObjectName(QLatin1String("SearchButton"));
+    setCursor(Qt::ArrowCursor);
+    setFocusPolicy(Qt::NoFocus);
+}
+
+void SearchButton::mousePressEvent(QMouseEvent *event)
+{
+    if (m_menu && event->button() == Qt::LeftButton) {
+        QWidget *p = parentWidget();
+        if (p) {
+            QPoint r = p->mapToGlobal(QPoint(0, p->height()));
+            m_menu->exec(QPoint(r.x() + height() / 2, r.y()));
+        }
+        event->accept();
+    }
+    QAbstractButton::mousePressEvent(event);
+}
+
+void SearchButton::paintEvent(QPaintEvent *event)
+{
+    Q_UNUSED(event);
+    QPainterPath myPath;
+
+    int radius = (height() / 5) * 2;
+    QRect circle(height() / 3 - 1, height() / 4, radius, radius);
+    myPath.addEllipse(circle);
+
+    myPath.arcMoveTo(circle, 300);
+    QPointF c = myPath.currentPosition();
+    int diff = height() / 7;
+    myPath.lineTo(qMin(width() - 2, (int)c.x() + diff), c.y() + diff);
+
+    QPainter painter(this);
+    painter.setRenderHint(QPainter::Antialiasing, true);
+    painter.setPen(QPen(Qt::darkGray, 2));
+    painter.drawPath(myPath);
+
+    if (m_menu) {
+        QPainterPath dropPath;
+        dropPath.arcMoveTo(circle, 320);
+        QPointF c = dropPath.currentPosition();
+        c = QPointF(c.x() + 3.5, c.y() + 0.5);
+        dropPath.moveTo(c);
+        dropPath.lineTo(c.x() + 4, c.y());
+        dropPath.lineTo(c.x() + 2, c.y() + 2);
+        dropPath.closeSubpath();
+        painter.setPen(Qt::darkGray);
+        painter.setBrush(Qt::darkGray);
+        painter.setRenderHint(QPainter::Antialiasing, false);
+        painter.drawPath(dropPath);
+    }
+    painter.end();
+}
+
+/*
+    SearchLineEdit is an enhanced QLineEdit
+    - A Search icon on the left with optional menu
+    - When there is no text and doesn't have focus an "inactive text" is displayed
+    - When there is text a clear button is displayed on the right hand side
+ */
+SearchLineEdit::SearchLineEdit(QWidget *parent) : ExLineEdit(parent),
+    m_searchButton(new SearchButton(this))
+{
+    connect(lineEdit(), SIGNAL(textChanged(const QString &)),
+            this, SIGNAL(textChanged(const QString &)));
+    setLeftWidget(m_searchButton);
+    m_inactiveText = tr("Search");
+
+    QSizePolicy policy = sizePolicy();
+    setSizePolicy(QSizePolicy::Preferred, policy.verticalPolicy());
+}
+
+void SearchLineEdit::paintEvent(QPaintEvent *event)
+{
+    if (lineEdit()->text().isEmpty() && !hasFocus() && !m_inactiveText.isEmpty()) {
+        ExLineEdit::paintEvent(event);
+        QStyleOptionFrameV2 panel;
+        initStyleOption(&panel);
+        QRect r = style()->subElementRect(QStyle::SE_LineEditContents, &panel, this);
+        QFontMetrics fm = fontMetrics();
+        int horizontalMargin = lineEdit()->x();
+        QRect lineRect(horizontalMargin + r.x(), r.y() + (r.height() - fm.height() + 1) / 2,
+                       r.width() - 2 * horizontalMargin, fm.height());
+        QPainter painter(this);
+        painter.setPen(palette().brush(QPalette::Disabled, QPalette::Text).color());
+        painter.drawText(lineRect, Qt::AlignLeft|Qt::AlignVCenter, m_inactiveText);
+    } else {
+        ExLineEdit::paintEvent(event);
+    }
+}
+
+void SearchLineEdit::resizeEvent(QResizeEvent *event)
+{
+    updateGeometries();
+    ExLineEdit::resizeEvent(event);
+}
+
+void SearchLineEdit::updateGeometries()
+{
+    int menuHeight = height();
+    int menuWidth = menuHeight + 1;
+    if (!m_searchButton->m_menu)
+        menuWidth = (menuHeight / 5) * 4;
+    m_searchButton->resize(QSize(menuWidth, menuHeight));
+}
+
+QString SearchLineEdit::inactiveText() const
+{
+    return m_inactiveText;
+}
+
+void SearchLineEdit::setInactiveText(const QString &text)
+{
+    m_inactiveText = text;
+}
+
+void SearchLineEdit::setMenu(QMenu *menu)
+{
+    if (m_searchButton->m_menu)
+        m_searchButton->m_menu->deleteLater();
+    m_searchButton->m_menu = menu;
+    updateGeometries();
+}
+
+QMenu *SearchLineEdit::menu() const
+{
+    if (!m_searchButton->m_menu) {
+        m_searchButton->m_menu = new QMenu(m_searchButton);
+        if (isVisible())
+            (const_cast<SearchLineEdit*>(this))->updateGeometries();
+    }
+    return m_searchButton->m_menu;
+}
+
diff --git a/examples/gestures/browser/searchlineedit.h b/examples/gestures/browser/searchlineedit.h
new file mode 100644
index 0000000..4fc887c
--- /dev/null
+++ b/examples/gestures/browser/searchlineedit.h
@@ -0,0 +1,103 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef SEARCHLINEEDIT_H
+#define SEARCHLINEEDIT_H
+
+#include "urllineedit.h"
+
+#include <QtGui/QLineEdit>
+#include <QtGui/QAbstractButton>
+
+QT_BEGIN_NAMESPACE
+class QMenu;
+QT_END_NAMESPACE
+
+class SearchButton;
+
+/*
+    Clear button on the right hand side of the search widget.
+    Hidden by default
+    "A circle with an X in it"
+ */
+class ClearButton : public QAbstractButton
+{
+    Q_OBJECT
+
+public:
+    ClearButton(QWidget *parent = 0);
+    void paintEvent(QPaintEvent *event);
+
+public slots:
+    void textChanged(const QString &text);
+};
+
+
+class SearchLineEdit : public ExLineEdit
+{
+    Q_OBJECT
+    Q_PROPERTY(QString inactiveText READ inactiveText WRITE setInactiveText)
+
+signals:
+    void textChanged(const QString &text);
+
+public:
+    SearchLineEdit(QWidget *parent = 0);
+
+    QString inactiveText() const;
+    void setInactiveText(const QString &text);
+
+    QMenu *menu() const;
+    void setMenu(QMenu *menu);
+
+protected:
+    void resizeEvent(QResizeEvent *event);
+    void paintEvent(QPaintEvent *event);
+
+private:
+    void updateGeometries();
+
+    SearchButton *m_searchButton;
+    QString m_inactiveText;
+};
+
+#endif // SEARCHLINEEDIT_H
+
diff --git a/examples/gestures/browser/settings.cpp b/examples/gestures/browser/settings.cpp
new file mode 100644
index 0000000..8f9f408
--- /dev/null
+++ b/examples/gestures/browser/settings.cpp
@@ -0,0 +1,324 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "settings.h"
+
+#include "browserapplication.h"
+#include "browsermainwindow.h"
+#include "cookiejar.h"
+#include "history.h"
+#include "networkaccessmanager.h"
+#include "webview.h"
+
+#include <QtCore/QSettings>
+#include <QtGui/QtGui>
+#include <QtWebKit/QtWebKit>
+
+SettingsDialog::SettingsDialog(QWidget *parent)
+    : QDialog(parent)
+{
+    setupUi(this);
+    connect(exceptionsButton, SIGNAL(clicked()), this, SLOT(showExceptions()));
+    connect(setHomeToCurrentPageButton, SIGNAL(clicked()), this, SLOT(setHomeToCurrentPage()));
+    connect(cookiesButton, SIGNAL(clicked()), this, SLOT(showCookies()));
+    connect(standardFontButton, SIGNAL(clicked()), this, SLOT(chooseFont()));
+    connect(fixedFontButton, SIGNAL(clicked()), this, SLOT(chooseFixedFont()));
+
+    loadDefaults();
+    loadFromSettings();
+}
+
+void SettingsDialog::loadDefaults()
+{
+    QWebSettings *defaultSettings = QWebSettings::globalSettings();
+    QString standardFontFamily = defaultSettings->fontFamily(QWebSettings::StandardFont);
+    int standardFontSize = defaultSettings->fontSize(QWebSettings::DefaultFontSize);
+    standardFont = QFont(standardFontFamily, standardFontSize);
+    standardLabel->setText(QString(QLatin1String("%1 %2")).arg(standardFont.family()).arg(standardFont.pointSize()));
+
+    QString fixedFontFamily = defaultSettings->fontFamily(QWebSettings::FixedFont);
+    int fixedFontSize = defaultSettings->fontSize(QWebSettings::DefaultFixedFontSize);
+    fixedFont = QFont(fixedFontFamily, fixedFontSize);
+    fixedLabel->setText(QString(QLatin1String("%1 %2")).arg(fixedFont.family()).arg(fixedFont.pointSize()));
+
+    downloadsLocation->setText(QDesktopServices::storageLocation(QDesktopServices::DesktopLocation));
+
+    enableJavascript->setChecked(defaultSettings->testAttribute(QWebSettings::JavascriptEnabled));
+    enablePlugins->setChecked(defaultSettings->testAttribute(QWebSettings::PluginsEnabled));
+}
+
+void SettingsDialog::loadFromSettings()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("MainWindow"));
+    QString defaultHome = QLatin1String("http://qtsoftware.com");
+    homeLineEdit->setText(settings.value(QLatin1String("home"), defaultHome).toString());
+    settings.endGroup();
+
+    settings.beginGroup(QLatin1String("history"));
+    int historyExpire = settings.value(QLatin1String("historyExpire")).toInt();
+    int idx = 0;
+    switch (historyExpire) {
+    case 1: idx = 0; break;
+    case 7: idx = 1; break;
+    case 14: idx = 2; break;
+    case 30: idx = 3; break;
+    case 365: idx = 4; break;
+    case -1: idx = 5; break;
+    default:
+        idx = 5;
+    }
+    expireHistory->setCurrentIndex(idx);
+    settings.endGroup();
+
+    settings.beginGroup(QLatin1String("downloadmanager"));
+    QString downloadDirectory = settings.value(QLatin1String("downloadDirectory"), downloadsLocation->text()).toString();
+    downloadsLocation->setText(downloadDirectory);
+    settings.endGroup();
+
+    settings.beginGroup(QLatin1String("general"));
+    openLinksIn->setCurrentIndex(settings.value(QLatin1String("openLinksIn"), openLinksIn->currentIndex()).toInt());
+
+    settings.endGroup();
+
+    // Appearance
+    settings.beginGroup(QLatin1String("websettings"));
+    fixedFont = qVariantValue<QFont>(settings.value(QLatin1String("fixedFont"), fixedFont));
+    standardFont = qVariantValue<QFont>(settings.value(QLatin1String("standardFont"), standardFont));
+
+    standardLabel->setText(QString(QLatin1String("%1 %2")).arg(standardFont.family()).arg(standardFont.pointSize()));
+    fixedLabel->setText(QString(QLatin1String("%1 %2")).arg(fixedFont.family()).arg(fixedFont.pointSize()));
+
+    enableJavascript->setChecked(settings.value(QLatin1String("enableJavascript"), enableJavascript->isChecked()).toBool());
+    enablePlugins->setChecked(settings.value(QLatin1String("enablePlugins"), enablePlugins->isChecked()).toBool());
+    userStyleSheet->setText(settings.value(QLatin1String("userStyleSheet")).toUrl().toString());
+    settings.endGroup();
+
+    // Privacy
+    settings.beginGroup(QLatin1String("cookies"));
+
+    CookieJar *jar = BrowserApplication::cookieJar();
+    QByteArray value = settings.value(QLatin1String("acceptCookies"), QLatin1String("AcceptOnlyFromSitesNavigatedTo")).toByteArray();
+    QMetaEnum acceptPolicyEnum = jar->staticMetaObject.enumerator(jar->staticMetaObject.indexOfEnumerator("AcceptPolicy"));
+    CookieJar::AcceptPolicy acceptCookies = acceptPolicyEnum.keyToValue(value) == -1 ?
+                        CookieJar::AcceptOnlyFromSitesNavigatedTo :
+                        static_cast<CookieJar::AcceptPolicy>(acceptPolicyEnum.keyToValue(value));
+    switch(acceptCookies) {
+    case CookieJar::AcceptAlways:
+        acceptCombo->setCurrentIndex(0);
+        break;
+    case CookieJar::AcceptNever:
+        acceptCombo->setCurrentIndex(1);
+        break;
+    case CookieJar::AcceptOnlyFromSitesNavigatedTo:
+        acceptCombo->setCurrentIndex(2);
+        break;
+    }
+
+    value = settings.value(QLatin1String("keepCookiesUntil"), QLatin1String("Expire")).toByteArray();
+    QMetaEnum keepPolicyEnum = jar->staticMetaObject.enumerator(jar->staticMetaObject.indexOfEnumerator("KeepPolicy"));
+    CookieJar::KeepPolicy keepCookies = keepPolicyEnum.keyToValue(value) == -1 ?
+                        CookieJar::KeepUntilExpire :
+                        static_cast<CookieJar::KeepPolicy>(keepPolicyEnum.keyToValue(value));
+    switch(keepCookies) {
+    case CookieJar::KeepUntilExpire:
+        keepUntilCombo->setCurrentIndex(0);
+        break;
+    case CookieJar::KeepUntilExit:
+        keepUntilCombo->setCurrentIndex(1);
+        break;
+    case CookieJar::KeepUntilTimeLimit:
+        keepUntilCombo->setCurrentIndex(2);
+        break;
+    }
+    settings.endGroup();
+
+
+    // Proxy
+    settings.beginGroup(QLatin1String("proxy"));
+    proxySupport->setChecked(settings.value(QLatin1String("enabled"), false).toBool());
+    proxyType->setCurrentIndex(settings.value(QLatin1String("type"), 0).toInt());
+    proxyHostName->setText(settings.value(QLatin1String("hostName")).toString());
+    proxyPort->setValue(settings.value(QLatin1String("port"), 1080).toInt());
+    proxyUserName->setText(settings.value(QLatin1String("userName")).toString());
+    proxyPassword->setText(settings.value(QLatin1String("password")).toString());
+    settings.endGroup();
+}
+
+void SettingsDialog::saveToSettings()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("MainWindow"));
+    settings.setValue(QLatin1String("home"), homeLineEdit->text());
+    settings.endGroup();
+
+    settings.beginGroup(QLatin1String("general"));
+    settings.setValue(QLatin1String("openLinksIn"), openLinksIn->currentIndex());
+    settings.endGroup();
+
+    settings.beginGroup(QLatin1String("history"));
+    int historyExpire = expireHistory->currentIndex();
+    int idx = -1;
+    switch (historyExpire) {
+    case 0: idx = 1; break;
+    case 1: idx = 7; break;
+    case 2: idx = 14; break;
+    case 3: idx = 30; break;
+    case 4: idx = 365; break;
+    case 5: idx = -1; break;
+    }
+    settings.setValue(QLatin1String("historyExpire"), idx);
+    settings.endGroup();
+
+    // Appearance
+    settings.beginGroup(QLatin1String("websettings"));
+    settings.setValue(QLatin1String("fixedFont"), fixedFont);
+    settings.setValue(QLatin1String("standardFont"), standardFont);
+    settings.setValue(QLatin1String("enableJavascript"), enableJavascript->isChecked());
+    settings.setValue(QLatin1String("enablePlugins"), enablePlugins->isChecked());
+    QString userStyleSheetString = userStyleSheet->text();
+    if (QFile::exists(userStyleSheetString))
+        settings.setValue(QLatin1String("userStyleSheet"), QUrl::fromLocalFile(userStyleSheetString));
+    else
+        settings.setValue(QLatin1String("userStyleSheet"), QUrl(userStyleSheetString));
+    settings.endGroup();
+
+    //Privacy
+    settings.beginGroup(QLatin1String("cookies"));
+
+    CookieJar::KeepPolicy keepCookies;
+    switch(acceptCombo->currentIndex()) {
+    default:
+    case 0:
+        keepCookies = CookieJar::KeepUntilExpire;
+        break;
+    case 1:
+        keepCookies = CookieJar::KeepUntilExit;
+        break;
+    case 2:
+        keepCookies = CookieJar::KeepUntilTimeLimit;
+        break;
+    }
+    CookieJar *jar = BrowserApplication::cookieJar();
+    QMetaEnum acceptPolicyEnum = jar->staticMetaObject.enumerator(jar->staticMetaObject.indexOfEnumerator("AcceptPolicy"));
+    settings.setValue(QLatin1String("acceptCookies"), QLatin1String(acceptPolicyEnum.valueToKey(keepCookies)));
+
+    CookieJar::KeepPolicy keepPolicy;
+    switch(keepUntilCombo->currentIndex()) {
+        default:
+    case 0:
+        keepPolicy = CookieJar::KeepUntilExpire;
+        break;
+    case 1:
+        keepPolicy = CookieJar::KeepUntilExit;
+        break;
+    case 2:
+        keepPolicy = CookieJar::KeepUntilTimeLimit;
+        break;
+    }
+
+    QMetaEnum keepPolicyEnum = jar->staticMetaObject.enumerator(jar->staticMetaObject.indexOfEnumerator("KeepPolicy"));
+    settings.setValue(QLatin1String("keepCookiesUntil"), QLatin1String(keepPolicyEnum.valueToKey(keepPolicy)));
+
+    settings.endGroup();
+
+    // proxy
+    settings.beginGroup(QLatin1String("proxy"));
+    settings.setValue(QLatin1String("enabled"), proxySupport->isChecked());
+    settings.setValue(QLatin1String("type"), proxyType->currentIndex());
+    settings.setValue(QLatin1String("hostName"), proxyHostName->text());
+    settings.setValue(QLatin1String("port"), proxyPort->text());
+    settings.setValue(QLatin1String("userName"), proxyUserName->text());
+    settings.setValue(QLatin1String("password"), proxyPassword->text());
+    settings.endGroup();
+
+    BrowserApplication::instance()->loadSettings();
+    BrowserApplication::networkAccessManager()->loadSettings();
+    BrowserApplication::cookieJar()->loadSettings();
+    BrowserApplication::historyManager()->loadSettings();
+}
+
+void SettingsDialog::accept()
+{
+    saveToSettings();
+    QDialog::accept();
+}
+
+void SettingsDialog::showCookies()
+{
+    CookiesDialog *dialog = new CookiesDialog(BrowserApplication::cookieJar(), this);
+    dialog->exec();
+}
+
+void SettingsDialog::showExceptions()
+{
+    CookiesExceptionsDialog *dialog = new CookiesExceptionsDialog(BrowserApplication::cookieJar(), this);
+    dialog->exec();
+}
+
+void SettingsDialog::chooseFont()
+{
+    bool ok;
+    QFont font = QFontDialog::getFont(&ok, standardFont, this);
+    if ( ok ) {
+        standardFont = font;
+        standardLabel->setText(QString(QLatin1String("%1 %2")).arg(font.family()).arg(font.pointSize()));
+    }
+}
+
+void SettingsDialog::chooseFixedFont()
+{
+    bool ok;
+    QFont font = QFontDialog::getFont(&ok, fixedFont, this);
+    if ( ok ) {
+        fixedFont = font;
+        fixedLabel->setText(QString(QLatin1String("%1 %2")).arg(font.family()).arg(font.pointSize()));
+    }
+}
+
+void SettingsDialog::setHomeToCurrentPage()
+{
+    BrowserMainWindow *mw = static_cast<BrowserMainWindow*>(parent());
+    WebView *webView = mw->currentTab();
+    if (webView)
+        homeLineEdit->setText(webView->url().toString());
+}
+
diff --git a/examples/gestures/browser/settings.h b/examples/gestures/browser/settings.h
new file mode 100644
index 0000000..a125dc2
--- /dev/null
+++ b/examples/gestures/browser/settings.h
@@ -0,0 +1,74 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef SETTINGS_H
+#define SETTINGS_H
+
+#include <QtGui/QDialog>
+#include "ui_settings.h"
+
+class SettingsDialog : public QDialog, public Ui_Settings
+{
+    Q_OBJECT
+
+public:
+    SettingsDialog(QWidget *parent = 0);
+    void accept();
+
+private slots:
+    void loadDefaults();
+    void loadFromSettings();
+    void saveToSettings();
+
+    void setHomeToCurrentPage();
+    void showCookies();
+    void showExceptions();
+
+    void chooseFont();
+    void chooseFixedFont();
+
+private:
+    QFont standardFont;
+    QFont fixedFont;
+};
+
+#endif // SETTINGS_H
+
diff --git a/examples/gestures/browser/settings.ui b/examples/gestures/browser/settings.ui
new file mode 100644
index 0000000..3491ce0
--- /dev/null
+++ b/examples/gestures/browser/settings.ui
@@ -0,0 +1,614 @@
+<ui version="4.0" >
+ <class>Settings</class>
+ <widget class="QDialog" name="Settings" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>657</width>
+    <height>322</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Settings</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout" >
+   <item row="2" column="0" >
+    <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>
+   <item row="1" column="0" >
+    <widget class="QTabWidget" name="tabWidget" >
+     <property name="currentIndex" >
+      <number>0</number>
+     </property>
+     <widget class="QWidget" name="tab" >
+      <property name="geometry" >
+       <rect>
+        <x>0</x>
+        <y>0</y>
+        <width>627</width>
+        <height>243</height>
+       </rect>
+      </property>
+      <attribute name="title" >
+       <string>General</string>
+      </attribute>
+      <layout class="QGridLayout" name="gridLayout_4" >
+       <item row="0" column="0" >
+        <widget class="QLabel" name="label_3" >
+         <property name="text" >
+          <string>Home:</string>
+         </property>
+         <property name="alignment" >
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="0" column="1" colspan="2" >
+        <widget class="QLineEdit" name="homeLineEdit" />
+       </item>
+       <item row="1" column="1" >
+        <widget class="QPushButton" name="setHomeToCurrentPageButton" >
+         <property name="text" >
+          <string>Set to current page</string>
+         </property>
+        </widget>
+       </item>
+       <item row="1" column="2" >
+        <spacer name="horizontalSpacer" >
+         <property name="orientation" >
+          <enum>Qt::Horizontal</enum>
+         </property>
+         <property name="sizeHint" stdset="0" >
+          <size>
+           <width>280</width>
+           <height>18</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+       <item row="2" column="0" >
+        <widget class="QLabel" name="label_4" >
+         <property name="text" >
+          <string>Remove history items:</string>
+         </property>
+         <property name="alignment" >
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="2" column="1" colspan="2" >
+        <widget class="QComboBox" name="expireHistory" >
+         <item>
+          <property name="text" >
+           <string>After one day</string>
+          </property>
+         </item>
+         <item>
+          <property name="text" >
+           <string>After one week</string>
+          </property>
+         </item>
+         <item>
+          <property name="text" >
+           <string>After two weeks</string>
+          </property>
+         </item>
+         <item>
+          <property name="text" >
+           <string>After one month</string>
+          </property>
+         </item>
+         <item>
+          <property name="text" >
+           <string>After one year</string>
+          </property>
+         </item>
+         <item>
+          <property name="text" >
+           <string>Manually</string>
+          </property>
+         </item>
+        </widget>
+       </item>
+       <item row="3" column="0" >
+        <widget class="QLabel" name="label_7" >
+         <property name="text" >
+          <string>Save downloads to:</string>
+         </property>
+         <property name="alignment" >
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="3" column="1" colspan="2" >
+        <widget class="QLineEdit" name="downloadsLocation" />
+       </item>
+       <item row="4" column="0" >
+        <widget class="QLabel" name="label_8" >
+         <property name="text" >
+          <string>Open links from applications:</string>
+         </property>
+         <property name="alignment" >
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="4" column="1" colspan="2" >
+        <widget class="QComboBox" name="openLinksIn" >
+         <item>
+          <property name="text" >
+           <string>In a tab in the current window</string>
+          </property>
+         </item>
+         <item>
+          <property name="text" >
+           <string>In a new window</string>
+          </property>
+         </item>
+        </widget>
+       </item>
+       <item row="5" column="1" colspan="2" >
+        <spacer>
+         <property name="orientation" >
+          <enum>Qt::Vertical</enum>
+         </property>
+         <property name="sizeHint" stdset="0" >
+          <size>
+           <width>391</width>
+           <height>262</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="tab_3" >
+      <property name="geometry" >
+       <rect>
+        <x>0</x>
+        <y>0</y>
+        <width>627</width>
+        <height>243</height>
+       </rect>
+      </property>
+      <attribute name="title" >
+       <string>Appearance</string>
+      </attribute>
+      <layout class="QGridLayout" name="gridLayout_3" >
+       <item row="0" column="0" >
+        <widget class="QLabel" name="label_5" >
+         <property name="text" >
+          <string>Standard font:</string>
+         </property>
+         <property name="alignment" >
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="0" column="1" >
+        <widget class="QLabel" name="standardLabel" >
+         <property name="sizePolicy" >
+          <sizepolicy vsizetype="Preferred" hsizetype="Expanding" >
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
+         <property name="frameShape" >
+          <enum>QFrame::StyledPanel</enum>
+         </property>
+         <property name="text" >
+          <string>Times 16</string>
+         </property>
+         <property name="alignment" >
+          <set>Qt::AlignCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="0" column="2" >
+        <widget class="QPushButton" name="standardFontButton" >
+         <property name="text" >
+          <string>Select...</string>
+         </property>
+        </widget>
+       </item>
+       <item row="1" column="0" >
+        <widget class="QLabel" name="label_6" >
+         <property name="text" >
+          <string>Fixed-width font:</string>
+         </property>
+         <property name="alignment" >
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="1" column="1" >
+        <widget class="QLabel" name="fixedLabel" >
+         <property name="frameShape" >
+          <enum>QFrame::StyledPanel</enum>
+         </property>
+         <property name="text" >
+          <string>Courier 13</string>
+         </property>
+         <property name="alignment" >
+          <set>Qt::AlignCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="1" column="2" >
+        <widget class="QPushButton" name="fixedFontButton" >
+         <property name="text" >
+          <string>Select...</string>
+         </property>
+        </widget>
+       </item>
+       <item row="2" column="1" >
+        <spacer name="verticalSpacer" >
+         <property name="orientation" >
+          <enum>Qt::Vertical</enum>
+         </property>
+         <property name="sizeHint" stdset="0" >
+          <size>
+           <width>20</width>
+           <height>93</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="tab_2" >
+      <property name="geometry" >
+       <rect>
+        <x>0</x>
+        <y>0</y>
+        <width>627</width>
+        <height>243</height>
+       </rect>
+      </property>
+      <attribute name="title" >
+       <string>Privacy</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_3" >
+       <item>
+        <widget class="QGroupBox" name="groupBox" >
+         <property name="title" >
+          <string>Web Content</string>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_2" >
+          <item>
+           <widget class="QCheckBox" name="enablePlugins" >
+            <property name="text" >
+             <string>Enable Plugins</string>
+            </property>
+            <property name="checked" >
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="enableJavascript" >
+            <property name="text" >
+             <string>Enable Javascript</string>
+            </property>
+            <property name="checked" >
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="cookiesGroupBox" >
+         <property name="title" >
+          <string>Cookies</string>
+         </property>
+         <layout class="QGridLayout" >
+          <item row="0" column="0" >
+           <widget class="QLabel" name="label_2" >
+            <property name="text" >
+             <string>Accept Cookies:</string>
+            </property>
+            <property name="alignment" >
+             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="1" >
+           <widget class="QComboBox" name="acceptCombo" >
+            <item>
+             <property name="text" >
+              <string>Always</string>
+             </property>
+            </item>
+            <item>
+             <property name="text" >
+              <string>Never</string>
+             </property>
+            </item>
+            <item>
+             <property name="text" >
+              <string>Only from sites you navigate to</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+          <item row="0" column="2" >
+           <widget class="QPushButton" name="exceptionsButton" >
+            <property name="text" >
+             <string>Exceptions...</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="0" >
+           <widget class="QLabel" name="label" >
+            <property name="text" >
+             <string>Keep until:</string>
+            </property>
+            <property name="alignment" >
+             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1" >
+           <widget class="QComboBox" name="keepUntilCombo" >
+            <item>
+             <property name="text" >
+              <string>They expire</string>
+             </property>
+            </item>
+            <item>
+             <property name="text" >
+              <string>I exit the application</string>
+             </property>
+            </item>
+            <item>
+             <property name="text" >
+              <string>At most 90 days</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+          <item row="1" column="2" >
+           <widget class="QPushButton" name="cookiesButton" >
+            <property name="text" >
+             <string>Cookies...</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <spacer>
+         <property name="orientation" >
+          <enum>Qt::Vertical</enum>
+         </property>
+         <property name="sizeHint" stdset="0" >
+          <size>
+           <width>371</width>
+           <height>177</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="tab_4" >
+      <property name="geometry" >
+       <rect>
+        <x>0</x>
+        <y>0</y>
+        <width>627</width>
+        <height>243</height>
+       </rect>
+      </property>
+      <attribute name="title" >
+       <string>Proxy</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout" >
+       <item>
+        <widget class="QGroupBox" name="proxySupport" >
+         <property name="title" >
+          <string>Enable proxy</string>
+         </property>
+         <property name="checkable" >
+          <bool>true</bool>
+         </property>
+         <layout class="QGridLayout" name="gridLayout_6" >
+          <item row="0" column="0" >
+           <widget class="QLabel" name="label_9" >
+            <property name="text" >
+             <string>Type:</string>
+            </property>
+            <property name="alignment" >
+             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="1" colspan="2" >
+           <widget class="QComboBox" name="proxyType" >
+            <item>
+             <property name="text" >
+              <string>Socks5</string>
+             </property>
+            </item>
+            <item>
+             <property name="text" >
+              <string>Http</string>
+             </property>
+            </item>
+           </widget>
+          </item>
+          <item row="1" column="0" >
+           <widget class="QLabel" name="label_10" >
+            <property name="text" >
+             <string>Host:</string>
+            </property>
+            <property name="alignment" >
+             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1" colspan="2" >
+           <widget class="QLineEdit" name="proxyHostName" />
+          </item>
+          <item row="2" column="0" >
+           <widget class="QLabel" name="label_11" >
+            <property name="text" >
+             <string>Port:</string>
+            </property>
+            <property name="alignment" >
+             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="1" >
+           <widget class="QSpinBox" name="proxyPort" >
+            <property name="maximum" >
+             <number>10000</number>
+            </property>
+            <property name="value" >
+             <number>1080</number>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="2" >
+           <spacer name="horizontalSpacer_2" >
+            <property name="orientation" >
+             <enum>Qt::Horizontal</enum>
+            </property>
+            <property name="sizeHint" stdset="0" >
+             <size>
+              <width>293</width>
+              <height>20</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+          <item row="3" column="0" >
+           <widget class="QLabel" name="label_12" >
+            <property name="text" >
+             <string>User Name:</string>
+            </property>
+            <property name="alignment" >
+             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="1" colspan="2" >
+           <widget class="QLineEdit" name="proxyUserName" />
+          </item>
+          <item row="4" column="0" >
+           <widget class="QLabel" name="label_13" >
+            <property name="text" >
+             <string>Password:</string>
+            </property>
+            <property name="alignment" >
+             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="4" column="1" colspan="2" >
+           <widget class="QLineEdit" name="proxyPassword" >
+            <property name="echoMode" >
+             <enum>QLineEdit::Password</enum>
+            </property>
+           </widget>
+          </item>
+          <item row="5" column="0" >
+           <spacer name="verticalSpacer_2" >
+            <property name="orientation" >
+             <enum>Qt::Vertical</enum>
+            </property>
+            <property name="sizeHint" stdset="0" >
+             <size>
+              <width>20</width>
+              <height>8</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="tab_5" >
+      <attribute name="title" >
+       <string>Advanced</string>
+      </attribute>
+      <layout class="QGridLayout" name="gridLayout_2" >
+       <item row="0" column="0" >
+        <widget class="QLabel" name="label_14" >
+         <property name="text" >
+          <string>Style Sheet:</string>
+         </property>
+        </widget>
+       </item>
+       <item row="0" column="1" >
+        <widget class="QLineEdit" name="userStyleSheet" />
+       </item>
+       <item row="1" column="1" >
+        <spacer name="verticalSpacer_3" >
+         <property name="orientation" >
+          <enum>Qt::Vertical</enum>
+         </property>
+         <property name="sizeHint" stdset="0" >
+          <size>
+           <width>20</width>
+           <height>176</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </widget>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>Settings</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>Settings</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/examples/gestures/browser/squeezelabel.cpp b/examples/gestures/browser/squeezelabel.cpp
new file mode 100644
index 0000000..f56db2d
--- /dev/null
+++ b/examples/gestures/browser/squeezelabel.cpp
@@ -0,0 +1,61 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "squeezelabel.h"
+
+SqueezeLabel::SqueezeLabel(QWidget *parent) : QLabel(parent)
+{
+}
+
+void SqueezeLabel::paintEvent(QPaintEvent *event)
+{
+    QFontMetrics fm = fontMetrics();
+    if (fm.width(text()) > contentsRect().width()) {
+        QString elided = fm.elidedText(text(), Qt::ElideMiddle, width());
+        QString oldText = text();
+        setText(elided);
+        QLabel::paintEvent(event);
+        setText(oldText);
+    } else {
+        QLabel::paintEvent(event);
+    }
+}
+
diff --git a/examples/gestures/browser/squeezelabel.h b/examples/gestures/browser/squeezelabel.h
new file mode 100644
index 0000000..f23b9a9
--- /dev/null
+++ b/examples/gestures/browser/squeezelabel.h
@@ -0,0 +1,60 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef SQUEEZELABEL_H
+#define SQUEEZELABEL_H
+
+#include <QtGui/QLabel>
+
+class SqueezeLabel : public QLabel
+{
+    Q_OBJECT
+
+public:
+    SqueezeLabel(QWidget *parent = 0);
+
+protected:
+    void paintEvent(QPaintEvent *event);
+
+};
+
+#endif // SQUEEZELABEL_H
+
diff --git a/examples/gestures/browser/tabwidget.cpp b/examples/gestures/browser/tabwidget.cpp
new file mode 100644
index 0000000..0c26350
--- /dev/null
+++ b/examples/gestures/browser/tabwidget.cpp
@@ -0,0 +1,830 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "tabwidget.h"
+
+#include "browserapplication.h"
+#include "browsermainwindow.h"
+#include "history.h"
+#include "urllineedit.h"
+#include "webview.h"
+
+#include <QtGui/QClipboard>
+#include <QtGui/QCompleter>
+#include <QtGui/QListView>
+#include <QtGui/QMenu>
+#include <QtGui/QMessageBox>
+#include <QtGui/QMouseEvent>
+#include <QtGui/QStackedWidget>
+#include <QtGui/QStyle>
+#include <QtGui/QToolButton>
+
+#include <QtCore/QDebug>
+
+TabBar::TabBar(QWidget *parent)
+    : QTabBar(parent)
+{
+    setContextMenuPolicy(Qt::CustomContextMenu);
+    setAcceptDrops(true);
+    connect(this, SIGNAL(customContextMenuRequested(const QPoint &)),
+            this, SLOT(contextMenuRequested(const QPoint &)));
+
+    QString alt = QLatin1String("Alt+%1");
+    for (int i = 1; i <= 10; ++i) {
+        int key = i;
+        if (key == 10)
+            key = 0;
+        QShortcut *shortCut = new QShortcut(alt.arg(key), this);
+        m_tabShortcuts.append(shortCut);
+        connect(shortCut, SIGNAL(activated()), this, SLOT(selectTabAction()));
+    }
+    setTabsClosable(true);
+    connect(this, SIGNAL(tabCloseRequested(int)),
+            this, SIGNAL(closeTab(int)));
+    setSelectionBehaviorOnRemove(QTabBar::SelectPreviousTab);
+    setMovable(true);
+}
+
+void TabBar::selectTabAction()
+{
+    if (QShortcut *shortCut = qobject_cast<QShortcut*>(sender())) {
+        int index = m_tabShortcuts.indexOf(shortCut);
+        if (index == 0)
+            index = 10;
+        setCurrentIndex(index);
+    }
+}
+
+void TabBar::contextMenuRequested(const QPoint &position)
+{
+    QMenu menu;
+    menu.addAction(tr("New &Tab"), this, SIGNAL(newTab()), QKeySequence::AddTab);
+    int index = tabAt(position);
+    if (-1 != index) {
+        QAction *action = menu.addAction(tr("Clone Tab"),
+                this, SLOT(cloneTab()));
+        action->setData(index);
+
+        menu.addSeparator();
+
+        action = menu.addAction(tr("&Close Tab"),
+                this, SLOT(closeTab()), QKeySequence::Close);
+        action->setData(index);
+
+        action = menu.addAction(tr("Close &Other Tabs"),
+                this, SLOT(closeOtherTabs()));
+        action->setData(index);
+
+        menu.addSeparator();
+
+        action = menu.addAction(tr("Reload Tab"),
+                this, SLOT(reloadTab()), QKeySequence::Refresh);
+        action->setData(index);
+    } else {
+        menu.addSeparator();
+    }
+    menu.addAction(tr("Reload All Tabs"), this, SIGNAL(reloadAllTabs()));
+    menu.exec(QCursor::pos());
+}
+
+void TabBar::cloneTab()
+{
+    if (QAction *action = qobject_cast<QAction*>(sender())) {
+        int index = action->data().toInt();
+        emit cloneTab(index);
+    }
+}
+
+void TabBar::closeTab()
+{
+    if (QAction *action = qobject_cast<QAction*>(sender())) {
+        int index = action->data().toInt();
+        emit closeTab(index);
+    }
+}
+
+void TabBar::closeOtherTabs()
+{
+    if (QAction *action = qobject_cast<QAction*>(sender())) {
+        int index = action->data().toInt();
+        emit closeOtherTabs(index);
+    }
+}
+
+void TabBar::mousePressEvent(QMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+        m_dragStartPos = event->pos();
+    QTabBar::mousePressEvent(event);
+}
+
+void TabBar::mouseMoveEvent(QMouseEvent *event)
+{
+    if (event->buttons() == Qt::LeftButton) {
+        int diffX = event->pos().x() - m_dragStartPos.x();
+        int diffY = event->pos().y() - m_dragStartPos.y();
+        if ((event->pos() - m_dragStartPos).manhattanLength() > QApplication::startDragDistance()
+            && diffX < 3 && diffX > -3
+            && diffY < -10) {
+            QDrag *drag = new QDrag(this);
+            QMimeData *mimeData = new QMimeData;
+            QList<QUrl> urls;
+            int index = tabAt(event->pos());
+            QUrl url = tabData(index).toUrl();
+            urls.append(url);
+            mimeData->setUrls(urls);
+            mimeData->setText(tabText(index));
+            mimeData->setData(QLatin1String("action"), "tab-reordering");
+            drag->setMimeData(mimeData);
+            drag->exec();
+        }
+    }
+    QTabBar::mouseMoveEvent(event);
+}
+
+// When index is -1 index chooses the current tab
+void TabWidget::reloadTab(int index)
+{
+    if (index < 0)
+        index = currentIndex();
+    if (index < 0 || index >= count())
+        return;
+
+    QWidget *widget = this->widget(index);
+    if (WebView *tab = qobject_cast<WebView*>(widget))
+        tab->reload();
+}
+
+void TabBar::reloadTab()
+{
+    if (QAction *action = qobject_cast<QAction*>(sender())) {
+        int index = action->data().toInt();
+        emit reloadTab(index);
+    }
+}
+
+TabWidget::TabWidget(QWidget *parent)
+    : QTabWidget(parent)
+    , m_recentlyClosedTabsAction(0)
+    , m_newTabAction(0)
+    , m_closeTabAction(0)
+    , m_nextTabAction(0)
+    , m_previousTabAction(0)
+    , m_recentlyClosedTabsMenu(0)
+    , m_lineEditCompleter(0)
+    , m_lineEdits(0)
+    , m_tabBar(new TabBar(this))
+{
+    setElideMode(Qt::ElideRight);
+
+    connect(m_tabBar, SIGNAL(newTab()), this, SLOT(newTab()));
+    connect(m_tabBar, SIGNAL(closeTab(int)), this, SLOT(closeTab(int)));
+    connect(m_tabBar, SIGNAL(cloneTab(int)), this, SLOT(cloneTab(int)));
+    connect(m_tabBar, SIGNAL(closeOtherTabs(int)), this, SLOT(closeOtherTabs(int)));
+    connect(m_tabBar, SIGNAL(reloadTab(int)), this, SLOT(reloadTab(int)));
+    connect(m_tabBar, SIGNAL(reloadAllTabs()), this, SLOT(reloadAllTabs()));
+    connect(m_tabBar, SIGNAL(tabMoved(int, int)), this, SLOT(moveTab(int, int)));
+    setTabBar(m_tabBar);
+    setDocumentMode(true);
+
+    // Actions
+    m_newTabAction = new QAction(QIcon(QLatin1String(":addtab.png")), tr("New &Tab"), this);
+    m_newTabAction->setShortcuts(QKeySequence::AddTab);
+    m_newTabAction->setIconVisibleInMenu(false);
+    connect(m_newTabAction, SIGNAL(triggered()), this, SLOT(newTab()));
+
+    m_closeTabAction = new QAction(QIcon(QLatin1String(":closetab.png")), tr("&Close Tab"), this);
+    m_closeTabAction->setShortcuts(QKeySequence::Close);
+    m_closeTabAction->setIconVisibleInMenu(false);
+    connect(m_closeTabAction, SIGNAL(triggered()), this, SLOT(closeTab()));
+
+    m_nextTabAction = new QAction(tr("Show Next Tab"), this);
+    QList<QKeySequence> shortcuts;
+    shortcuts.append(QKeySequence(Qt::CTRL | Qt::Key_BraceRight));
+    shortcuts.append(QKeySequence(Qt::CTRL | Qt::Key_PageDown));
+    shortcuts.append(QKeySequence(Qt::CTRL | Qt::Key_BracketRight));
+    shortcuts.append(QKeySequence(Qt::CTRL | Qt::Key_Less));
+    m_nextTabAction->setShortcuts(shortcuts);
+    connect(m_nextTabAction, SIGNAL(triggered()), this, SLOT(nextTab()));
+
+    m_previousTabAction = new QAction(tr("Show Previous Tab"), this);
+    shortcuts.clear();
+    shortcuts.append(QKeySequence(Qt::CTRL | Qt::Key_BraceLeft));
+    shortcuts.append(QKeySequence(Qt::CTRL | Qt::Key_PageUp));
+    shortcuts.append(QKeySequence(Qt::CTRL | Qt::Key_BracketLeft));
+    shortcuts.append(QKeySequence(Qt::CTRL | Qt::Key_Greater));
+    m_previousTabAction->setShortcuts(shortcuts);
+    connect(m_previousTabAction, SIGNAL(triggered()), this, SLOT(previousTab()));
+
+    m_recentlyClosedTabsMenu = new QMenu(this);
+    connect(m_recentlyClosedTabsMenu, SIGNAL(aboutToShow()),
+            this, SLOT(aboutToShowRecentTabsMenu()));
+    connect(m_recentlyClosedTabsMenu, SIGNAL(triggered(QAction *)),
+            this, SLOT(aboutToShowRecentTriggeredAction(QAction *)));
+    m_recentlyClosedTabsAction = new QAction(tr("Recently Closed Tabs"), this);
+    m_recentlyClosedTabsAction->setMenu(m_recentlyClosedTabsMenu);
+    m_recentlyClosedTabsAction->setEnabled(false);
+
+    connect(this, SIGNAL(currentChanged(int)),
+            this, SLOT(currentChanged(int)));
+
+    m_lineEdits = new QStackedWidget(this);
+}
+
+void TabWidget::clear()
+{
+    // clear the recently closed tabs
+    m_recentlyClosedTabs.clear();
+    // clear the line edit history
+    for (int i = 0; i < m_lineEdits->count(); ++i) {
+        QLineEdit *qLineEdit = lineEdit(i);
+        qLineEdit->setText(qLineEdit->text());
+    }
+}
+
+void TabWidget::moveTab(int fromIndex, int toIndex)
+{
+    QWidget *lineEdit = m_lineEdits->widget(fromIndex);
+    m_lineEdits->removeWidget(lineEdit);
+    m_lineEdits->insertWidget(toIndex, lineEdit);
+}
+
+void TabWidget::addWebAction(QAction *action, QWebPage::WebAction webAction)
+{
+    if (!action)
+        return;
+    m_actions.append(new WebActionMapper(action, webAction, this));
+}
+
+void TabWidget::currentChanged(int index)
+{
+    WebView *webView = this->webView(index);
+    if (!webView)
+        return;
+
+    Q_ASSERT(m_lineEdits->count() == count());
+
+    WebView *oldWebView = this->webView(m_lineEdits->currentIndex());
+    if (oldWebView) {
+        disconnect(oldWebView, SIGNAL(statusBarMessage(const QString&)),
+                this, SIGNAL(showStatusBarMessage(const QString&)));
+        disconnect(oldWebView->page(), SIGNAL(linkHovered(const QString&, const QString&, const QString&)),
+                this, SIGNAL(linkHovered(const QString&)));
+        disconnect(oldWebView, SIGNAL(loadProgress(int)),
+                this, SIGNAL(loadProgress(int)));
+    }
+
+    connect(webView, SIGNAL(statusBarMessage(const QString&)),
+            this, SIGNAL(showStatusBarMessage(const QString&)));
+    connect(webView->page(), SIGNAL(linkHovered(const QString&, const QString&, const QString&)),
+            this, SIGNAL(linkHovered(const QString&)));
+    connect(webView, SIGNAL(loadProgress(int)),
+            this, SIGNAL(loadProgress(int)));
+
+    for (int i = 0; i < m_actions.count(); ++i) {
+        WebActionMapper *mapper = m_actions[i];
+        mapper->updateCurrent(webView->page());
+    }
+    emit setCurrentTitle(webView->title());
+    m_lineEdits->setCurrentIndex(index);
+    emit loadProgress(webView->progress());
+    emit showStatusBarMessage(webView->lastStatusBarText());
+    if (webView->url().isEmpty())
+        m_lineEdits->currentWidget()->setFocus();
+    else
+        webView->setFocus();
+}
+
+QAction *TabWidget::newTabAction() const
+{
+    return m_newTabAction;
+}
+
+QAction *TabWidget::closeTabAction() const
+{
+    return m_closeTabAction;
+}
+
+QAction *TabWidget::recentlyClosedTabsAction() const
+{
+    return m_recentlyClosedTabsAction;
+}
+
+QAction *TabWidget::nextTabAction() const
+{
+    return m_nextTabAction;
+}
+
+QAction *TabWidget::previousTabAction() const
+{
+    return m_previousTabAction;
+}
+
+QWidget *TabWidget::lineEditStack() const
+{
+    return m_lineEdits;
+}
+
+QLineEdit *TabWidget::currentLineEdit() const
+{
+    return lineEdit(m_lineEdits->currentIndex());
+}
+
+WebView *TabWidget::currentWebView() const
+{
+    return webView(currentIndex());
+}
+
+QLineEdit *TabWidget::lineEdit(int index) const
+{
+    UrlLineEdit *urlLineEdit = qobject_cast<UrlLineEdit*>(m_lineEdits->widget(index));
+    if (urlLineEdit)
+        return urlLineEdit->lineEdit();
+    return 0;
+}
+
+WebView *TabWidget::webView(int index) const
+{
+    QWidget *widget = this->widget(index);
+    if (WebView *webView = qobject_cast<WebView*>(widget)) {
+        return webView;
+    } else {
+        // optimization to delay creating the first webview
+        if (count() == 1) {
+            TabWidget *that = const_cast<TabWidget*>(this);
+            that->setUpdatesEnabled(false);
+            that->newTab();
+            that->closeTab(0);
+            that->setUpdatesEnabled(true);
+            return currentWebView();
+        }
+    }
+    return 0;
+}
+
+int TabWidget::webViewIndex(WebView *webView) const
+{
+    int index = indexOf(webView);
+    return index;
+}
+
+WebView *TabWidget::newTab(bool makeCurrent)
+{
+    // line edit
+    UrlLineEdit *urlLineEdit = new UrlLineEdit;
+    QLineEdit *lineEdit = urlLineEdit->lineEdit();
+    if (!m_lineEditCompleter && count() > 0) {
+        HistoryCompletionModel *completionModel = new HistoryCompletionModel(this);
+        completionModel->setSourceModel(BrowserApplication::historyManager()->historyFilterModel());
+        m_lineEditCompleter = new QCompleter(completionModel, this);
+        // Should this be in Qt by default?
+        QAbstractItemView *popup = m_lineEditCompleter->popup();
+        QListView *listView = qobject_cast<QListView*>(popup);
+        if (listView)
+            listView->setUniformItemSizes(true);
+    }
+    lineEdit->setCompleter(m_lineEditCompleter);
+    connect(lineEdit, SIGNAL(returnPressed()), this, SLOT(lineEditReturnPressed()));
+    m_lineEdits->addWidget(urlLineEdit);
+    m_lineEdits->setSizePolicy(lineEdit->sizePolicy());
+
+    // optimization to delay creating the more expensive WebView, history, etc
+    if (count() == 0) {
+        QWidget *emptyWidget = new QWidget;
+        QPalette p = emptyWidget->palette();
+        p.setColor(QPalette::Window, palette().color(QPalette::Base));
+        emptyWidget->setPalette(p);
+        emptyWidget->setAutoFillBackground(true);
+        disconnect(this, SIGNAL(currentChanged(int)),
+            this, SLOT(currentChanged(int)));
+        addTab(emptyWidget, tr("(Untitled)"));
+        connect(this, SIGNAL(currentChanged(int)),
+            this, SLOT(currentChanged(int)));
+        return 0;
+    }
+
+    // webview
+    WebView *webView = new WebView;
+    urlLineEdit->setWebView(webView);
+    connect(webView, SIGNAL(loadStarted()),
+            this, SLOT(webViewLoadStarted()));
+    connect(webView, SIGNAL(loadFinished(bool)),
+            this, SLOT(webViewIconChanged()));
+    connect(webView, SIGNAL(iconChanged()),
+            this, SLOT(webViewIconChanged()));
+    connect(webView, SIGNAL(titleChanged(const QString &)),
+            this, SLOT(webViewTitleChanged(const QString &)));
+    connect(webView, SIGNAL(urlChanged(const QUrl &)),
+            this, SLOT(webViewUrlChanged(const QUrl &)));
+    connect(webView->page(), SIGNAL(windowCloseRequested()),
+            this, SLOT(windowCloseRequested()));
+    connect(webView->page(), SIGNAL(geometryChangeRequested(const QRect &)),
+            this, SIGNAL(geometryChangeRequested(const QRect &)));
+    connect(webView->page(), SIGNAL(printRequested(QWebFrame *)),
+            this, SIGNAL(printRequested(QWebFrame *)));
+    connect(webView->page(), SIGNAL(menuBarVisibilityChangeRequested(bool)),
+            this, SIGNAL(menuBarVisibilityChangeRequested(bool)));
+    connect(webView->page(), SIGNAL(statusBarVisibilityChangeRequested(bool)),
+            this, SIGNAL(statusBarVisibilityChangeRequested(bool)));
+    connect(webView->page(), SIGNAL(toolBarVisibilityChangeRequested(bool)),
+            this, SIGNAL(toolBarVisibilityChangeRequested(bool)));
+    addTab(webView, tr("(Untitled)"));
+    if (makeCurrent)
+        setCurrentWidget(webView);
+
+    // webview actions
+    for (int i = 0; i < m_actions.count(); ++i) {
+        WebActionMapper *mapper = m_actions[i];
+        mapper->addChild(webView->page()->action(mapper->webAction()));
+    }
+
+    if (count() == 1)
+        currentChanged(currentIndex());
+    emit tabsChanged();
+    return webView;
+}
+
+void TabWidget::reloadAllTabs()
+{
+    for (int i = 0; i < count(); ++i) {
+        QWidget *tabWidget = widget(i);
+        if (WebView *tab = qobject_cast<WebView*>(tabWidget)) {
+            tab->reload();
+        }
+    }
+}
+
+void TabWidget::lineEditReturnPressed()
+{
+    if (QLineEdit *lineEdit = qobject_cast<QLineEdit*>(sender())) {
+        emit loadPage(lineEdit->text());
+        if (m_lineEdits->currentWidget() == lineEdit)
+            currentWebView()->setFocus();
+    }
+}
+
+void TabWidget::windowCloseRequested()
+{
+    WebPage *webPage = qobject_cast<WebPage*>(sender());
+    WebView *webView = qobject_cast<WebView*>(webPage->view());
+    int index = webViewIndex(webView);
+    if (index >= 0) {
+        if (count() == 1)
+            webView->webPage()->mainWindow()->close();
+        else
+            closeTab(index);
+    }
+}
+
+void TabWidget::closeOtherTabs(int index)
+{
+    if (-1 == index)
+        return;
+    for (int i = count() - 1; i > index; --i)
+        closeTab(i);
+    for (int i = index - 1; i >= 0; --i)
+        closeTab(i);
+}
+
+// When index is -1 index chooses the current tab
+void TabWidget::cloneTab(int index)
+{
+    if (index < 0)
+        index = currentIndex();
+    if (index < 0 || index >= count())
+        return;
+    WebView *tab = newTab(false);
+    tab->setUrl(webView(index)->url());
+}
+
+// When index is -1 index chooses the current tab
+void TabWidget::closeTab(int index)
+{
+    if (index < 0)
+        index = currentIndex();
+    if (index < 0 || index >= count())
+        return;
+
+    bool hasFocus = false;
+    if (WebView *tab = webView(index)) {
+        if (tab->isModified()) {
+            QMessageBox closeConfirmation(tab);
+            closeConfirmation.setWindowFlags(Qt::Sheet);
+            closeConfirmation.setWindowTitle(tr("Do you really want to close this page?"));
+            closeConfirmation.setInformativeText(tr("You have modified this page and when closing it you would lose the modification.\n"
+                                                     "Do you really want to close this page?\n"));
+            closeConfirmation.setIcon(QMessageBox::Question);
+            closeConfirmation.addButton(QMessageBox::Yes);
+            closeConfirmation.addButton(QMessageBox::No);
+            closeConfirmation.setEscapeButton(QMessageBox::No);
+            if (closeConfirmation.exec() == QMessageBox::No)
+                return;
+        }
+        hasFocus = tab->hasFocus();
+
+        m_recentlyClosedTabsAction->setEnabled(true);
+        m_recentlyClosedTabs.prepend(tab->url());
+        if (m_recentlyClosedTabs.size() >= TabWidget::m_recentlyClosedTabsSize)
+            m_recentlyClosedTabs.removeLast();
+    }
+    QWidget *lineEdit = m_lineEdits->widget(index);
+    m_lineEdits->removeWidget(lineEdit);
+    lineEdit->deleteLater();
+    QWidget *webView = widget(index);
+    removeTab(index);
+    webView->deleteLater();
+    emit tabsChanged();
+    if (hasFocus && count() > 0)
+        currentWebView()->setFocus();
+    if (count() == 0)
+        emit lastTabClosed();
+}
+
+void TabWidget::webViewLoadStarted()
+{
+    WebView *webView = qobject_cast<WebView*>(sender());
+    int index = webViewIndex(webView);
+    if (-1 != index) {
+        QIcon icon(QLatin1String(":loading.gif"));
+        setTabIcon(index, icon);
+    }
+}
+
+void TabWidget::webViewIconChanged()
+{
+    WebView *webView = qobject_cast<WebView*>(sender());
+    int index = webViewIndex(webView);
+    if (-1 != index) {
+        QIcon icon = BrowserApplication::instance()->icon(webView->url());
+        setTabIcon(index, icon);
+    }
+}
+
+void TabWidget::webViewTitleChanged(const QString &title)
+{
+    WebView *webView = qobject_cast<WebView*>(sender());
+    int index = webViewIndex(webView);
+    if (-1 != index) {
+        setTabText(index, title);
+    }
+    if (currentIndex() == index)
+        emit setCurrentTitle(title);
+    BrowserApplication::historyManager()->updateHistoryItem(webView->url(), title);
+}
+
+void TabWidget::webViewUrlChanged(const QUrl &url)
+{
+    WebView *webView = qobject_cast<WebView*>(sender());
+    int index = webViewIndex(webView);
+    if (-1 != index) {
+        m_tabBar->setTabData(index, url);
+    }
+    emit tabsChanged();
+}
+
+void TabWidget::aboutToShowRecentTabsMenu()
+{
+    m_recentlyClosedTabsMenu->clear();
+    for (int i = 0; i < m_recentlyClosedTabs.count(); ++i) {
+        QAction *action = new QAction(m_recentlyClosedTabsMenu);
+        action->setData(m_recentlyClosedTabs.at(i));
+        QIcon icon = BrowserApplication::instance()->icon(m_recentlyClosedTabs.at(i));
+        action->setIcon(icon);
+        action->setText(m_recentlyClosedTabs.at(i).toString());
+        m_recentlyClosedTabsMenu->addAction(action);
+    }
+}
+
+void TabWidget::aboutToShowRecentTriggeredAction(QAction *action)
+{
+    QUrl url = action->data().toUrl();
+    loadUrlInCurrentTab(url);
+}
+
+void TabWidget::mouseDoubleClickEvent(QMouseEvent *event)
+{
+    if (!childAt(event->pos())
+            // Remove the line below when QTabWidget does not have a one pixel frame
+            && event->pos().y() < (tabBar()->y() + tabBar()->height())) {
+        newTab();
+        return;
+    }
+    QTabWidget::mouseDoubleClickEvent(event);
+}
+
+void TabWidget::contextMenuEvent(QContextMenuEvent *event)
+{
+    if (!childAt(event->pos())) {
+        m_tabBar->contextMenuRequested(event->pos());
+        return;
+    }
+    QTabWidget::contextMenuEvent(event);
+}
+
+void TabWidget::mouseReleaseEvent(QMouseEvent *event)
+{
+    if (event->button() == Qt::MidButton && !childAt(event->pos())
+            // Remove the line below when QTabWidget does not have a one pixel frame
+            && event->pos().y() < (tabBar()->y() + tabBar()->height())) {
+        QUrl url(QApplication::clipboard()->text(QClipboard::Selection));
+        if (!url.isEmpty() && url.isValid() && !url.scheme().isEmpty()) {
+            WebView *webView = newTab();
+            webView->setUrl(url);
+        }
+    }
+}
+
+void TabWidget::loadUrlInCurrentTab(const QUrl &url)
+{
+    WebView *webView = currentWebView();
+    if (webView) {
+        webView->loadUrl(url);
+        webView->setFocus();
+    }
+}
+
+void TabWidget::nextTab()
+{
+    int next = currentIndex() + 1;
+    if (next == count())
+        next = 0;
+    setCurrentIndex(next);
+}
+
+void TabWidget::previousTab()
+{
+    int next = currentIndex() - 1;
+    if (next < 0)
+        next = count() - 1;
+    setCurrentIndex(next);
+}
+
+static const qint32 TabWidgetMagic = 0xaa;
+
+QByteArray TabWidget::saveState() const
+{
+    int version = 1;
+    QByteArray data;
+    QDataStream stream(&data, QIODevice::WriteOnly);
+
+    stream << qint32(TabWidgetMagic);
+    stream << qint32(version);
+
+    QStringList tabs;
+    for (int i = 0; i < count(); ++i) {
+        if (WebView *tab = qobject_cast<WebView*>(widget(i))) {
+            tabs.append(tab->url().toString());
+        } else {
+            tabs.append(QString::null);
+        }
+    }
+    stream << tabs;
+    stream << currentIndex();
+    return data;
+}
+
+bool TabWidget::restoreState(const QByteArray &state)
+{
+    int version = 1;
+    QByteArray sd = state;
+    QDataStream stream(&sd, QIODevice::ReadOnly);
+    if (stream.atEnd())
+        return false;
+
+    qint32 marker;
+    qint32 v;
+    stream >> marker;
+    stream >> v;
+    if (marker != TabWidgetMagic || v != version)
+        return false;
+
+    QStringList openTabs;
+    stream >> openTabs;
+
+    for (int i = 0; i < openTabs.count(); ++i) {
+        if (i != 0)
+            newTab();
+        loadPage(openTabs.at(i));
+    }
+
+    int currentTab;
+    stream >> currentTab;
+    setCurrentIndex(currentTab);
+
+    return true;
+}
+
+WebActionMapper::WebActionMapper(QAction *root, QWebPage::WebAction webAction, QObject *parent)
+    : QObject(parent)
+    , m_currentParent(0)
+    , m_root(root)
+    , m_webAction(webAction)
+{
+    if (!m_root)
+        return;
+    connect(m_root, SIGNAL(triggered()), this, SLOT(rootTriggered()));
+    connect(root, SIGNAL(destroyed(QObject *)), this, SLOT(rootDestroyed()));
+    root->setEnabled(false);
+}
+
+void WebActionMapper::rootDestroyed()
+{
+    m_root = 0;
+}
+
+void WebActionMapper::currentDestroyed()
+{
+    updateCurrent(0);
+}
+
+void WebActionMapper::addChild(QAction *action)
+{
+    if (!action)
+        return;
+    connect(action, SIGNAL(changed()), this, SLOT(childChanged()));
+}
+
+QWebPage::WebAction WebActionMapper::webAction() const
+{
+    return m_webAction;
+}
+
+void WebActionMapper::rootTriggered()
+{
+    if (m_currentParent) {
+        QAction *gotoAction = m_currentParent->action(m_webAction);
+        gotoAction->trigger();
+    }
+}
+
+void WebActionMapper::childChanged()
+{
+    if (QAction *source = qobject_cast<QAction*>(sender())) {
+        if (m_root
+            && m_currentParent
+            && source->parent() == m_currentParent) {
+            m_root->setChecked(source->isChecked());
+            m_root->setEnabled(source->isEnabled());
+        }
+    }
+}
+
+void WebActionMapper::updateCurrent(QWebPage *currentParent)
+{
+    if (m_currentParent)
+        disconnect(m_currentParent, SIGNAL(destroyed(QObject *)),
+                   this, SLOT(currentDestroyed()));
+
+    m_currentParent = currentParent;
+    if (!m_root)
+        return;
+    if (!m_currentParent) {
+        m_root->setEnabled(false);
+        m_root->setChecked(false);
+        return;
+    }
+    QAction *source = m_currentParent->action(m_webAction);
+    m_root->setChecked(source->isChecked());
+    m_root->setEnabled(source->isEnabled());
+    connect(m_currentParent, SIGNAL(destroyed(QObject *)),
+            this, SLOT(currentDestroyed()));
+}
+
diff --git a/examples/gestures/browser/tabwidget.h b/examples/gestures/browser/tabwidget.h
new file mode 100644
index 0000000..3f4e9f0
--- /dev/null
+++ b/examples/gestures/browser/tabwidget.h
@@ -0,0 +1,224 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef TABWIDGET_H
+#define TABWIDGET_H
+
+#include <QtGui/QTabBar>
+
+#include <QtGui/QShortcut>
+/*
+    Tab bar with a few more features such as a context menu and shortcuts
+ */
+class TabBar : public QTabBar
+{
+    Q_OBJECT
+
+signals:
+    void newTab();
+    void cloneTab(int index);
+    void closeTab(int index);
+    void closeOtherTabs(int index);
+    void reloadTab(int index);
+    void reloadAllTabs();
+    void tabMoveRequested(int fromIndex, int toIndex);
+
+public:
+    TabBar(QWidget *parent = 0);
+
+protected:
+    void mousePressEvent(QMouseEvent* event);
+    void mouseMoveEvent(QMouseEvent* event);
+
+private slots:
+    void selectTabAction();
+    void cloneTab();
+    void closeTab();
+    void closeOtherTabs();
+    void reloadTab();
+    void contextMenuRequested(const QPoint &position);
+
+private:
+    QList<QShortcut*> m_tabShortcuts;
+    friend class TabWidget;
+
+    QPoint m_dragStartPos;
+    int m_dragCurrentIndex;
+};
+
+#include <QtWebKit/QWebPage>
+
+QT_BEGIN_NAMESPACE
+class QAction;
+QT_END_NAMESPACE
+class WebView;
+/*!
+    A proxy object that connects a single browser action
+    to one child webpage action at a time.
+
+    Example usage: used to keep the main window stop action in sync with
+    the current tabs webview's stop action.
+ */
+class WebActionMapper : public QObject
+{
+    Q_OBJECT
+
+public:
+    WebActionMapper(QAction *root, QWebPage::WebAction webAction, QObject *parent);
+    QWebPage::WebAction webAction() const;
+    void addChild(QAction *action);
+    void updateCurrent(QWebPage *currentParent);
+
+private slots:
+    void rootTriggered();
+    void childChanged();
+    void rootDestroyed();
+    void currentDestroyed();
+
+private:
+    QWebPage *m_currentParent;
+    QAction *m_root;
+    QWebPage::WebAction m_webAction;
+};
+
+#include <QtCore/QUrl>
+#include <QtGui/QTabWidget>
+QT_BEGIN_NAMESPACE
+class QCompleter;
+class QLineEdit;
+class QMenu;
+class QStackedWidget;
+QT_END_NAMESPACE
+/*!
+    TabWidget that contains WebViews and a stack widget of associated line edits.
+
+    Connects up the current tab's signals to this class's signal and uses WebActionMapper
+    to proxy the actions.
+ */
+class TabWidget : public QTabWidget
+{
+    Q_OBJECT
+
+signals:
+    // tab widget signals
+    void loadPage(const QString &url);
+    void tabsChanged();
+    void lastTabClosed();
+
+    // current tab signals
+    void setCurrentTitle(const QString &url);
+    void showStatusBarMessage(const QString &message);
+    void linkHovered(const QString &link);
+    void loadProgress(int progress);
+    void geometryChangeRequested(const QRect &geometry);
+    void menuBarVisibilityChangeRequested(bool visible);
+    void statusBarVisibilityChangeRequested(bool visible);
+    void toolBarVisibilityChangeRequested(bool visible);
+    void printRequested(QWebFrame *frame);
+
+public:
+    TabWidget(QWidget *parent = 0);
+    void clear();
+    void addWebAction(QAction *action, QWebPage::WebAction webAction);
+
+    QAction *newTabAction() const;
+    QAction *closeTabAction() const;
+    QAction *recentlyClosedTabsAction() const;
+    QAction *nextTabAction() const;
+    QAction *previousTabAction() const;
+
+    QWidget *lineEditStack() const;
+    QLineEdit *currentLineEdit() const;
+    WebView *currentWebView() const;
+    WebView *webView(int index) const;
+    QLineEdit *lineEdit(int index) const;
+    int webViewIndex(WebView *webView) const;
+
+    QByteArray saveState() const;
+    bool restoreState(const QByteArray &state);
+
+protected:
+    void mouseDoubleClickEvent(QMouseEvent *event);
+    void contextMenuEvent(QContextMenuEvent *event);
+    void mouseReleaseEvent(QMouseEvent *event);
+
+public slots:
+    void loadUrlInCurrentTab(const QUrl &url);
+    WebView *newTab(bool makeCurrent = true);
+    void cloneTab(int index = -1);
+    void closeTab(int index = -1);
+    void closeOtherTabs(int index);
+    void reloadTab(int index = -1);
+    void reloadAllTabs();
+    void nextTab();
+    void previousTab();
+
+private slots:
+    void currentChanged(int index);
+    void aboutToShowRecentTabsMenu();
+    void aboutToShowRecentTriggeredAction(QAction *action);
+    void webViewLoadStarted();
+    void webViewIconChanged();
+    void webViewTitleChanged(const QString &title);
+    void webViewUrlChanged(const QUrl &url);
+    void lineEditReturnPressed();
+    void windowCloseRequested();
+    void moveTab(int fromIndex, int toIndex);
+
+private:
+    QAction *m_recentlyClosedTabsAction;
+    QAction *m_newTabAction;
+    QAction *m_closeTabAction;
+    QAction *m_nextTabAction;
+    QAction *m_previousTabAction;
+
+    QMenu *m_recentlyClosedTabsMenu;
+    static const int m_recentlyClosedTabsSize = 10;
+    QList<QUrl> m_recentlyClosedTabs;
+    QList<WebActionMapper*> m_actions;
+
+    QCompleter *m_lineEditCompleter;
+    QStackedWidget *m_lineEdits;
+    TabBar *m_tabBar;
+};
+
+#endif // TABWIDGET_H
+
diff --git a/examples/gestures/browser/toolbarsearch.cpp b/examples/gestures/browser/toolbarsearch.cpp
new file mode 100644
index 0000000..f26459c
--- /dev/null
+++ b/examples/gestures/browser/toolbarsearch.cpp
@@ -0,0 +1,161 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "toolbarsearch.h"
+#include "autosaver.h"
+
+#include <QtCore/QSettings>
+#include <QtCore/QUrl>
+
+#include <QtGui/QCompleter>
+#include <QtGui/QMenu>
+#include <QtGui/QStringListModel>
+
+#include <QtWebKit/QWebSettings>
+
+/*
+    ToolbarSearch is a very basic search widget that also contains a small history.
+    Searches are turned into urls that use Google to perform search
+ */
+ToolbarSearch::ToolbarSearch(QWidget *parent)
+    : SearchLineEdit(parent)
+    , m_autosaver(new AutoSaver(this))
+    , m_maxSavedSearches(10)
+    , m_stringListModel(new QStringListModel(this))
+{
+    QMenu *m = menu();
+    connect(m, SIGNAL(aboutToShow()), this, SLOT(aboutToShowMenu()));
+    connect(m, SIGNAL(triggered(QAction*)), this, SLOT(triggeredMenuAction(QAction*)));
+
+    QCompleter *completer = new QCompleter(m_stringListModel, this);
+    completer->setCompletionMode(QCompleter::InlineCompletion);
+    lineEdit()->setCompleter(completer);
+
+    connect(lineEdit(), SIGNAL(returnPressed()), SLOT(searchNow()));
+    setInactiveText(tr("Google"));
+    load();
+}
+
+ToolbarSearch::~ToolbarSearch()
+{
+    m_autosaver->saveIfNeccessary();
+}
+
+void ToolbarSearch::save()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("toolbarsearch"));
+    settings.setValue(QLatin1String("recentSearches"), m_stringListModel->stringList());
+    settings.setValue(QLatin1String("maximumSaved"), m_maxSavedSearches);
+    settings.endGroup();
+}
+
+void ToolbarSearch::load()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("toolbarsearch"));
+    QStringList list = settings.value(QLatin1String("recentSearches")).toStringList();
+    m_maxSavedSearches = settings.value(QLatin1String("maximumSaved"), m_maxSavedSearches).toInt();
+    m_stringListModel->setStringList(list);
+    settings.endGroup();
+}
+
+void ToolbarSearch::searchNow()
+{
+    QString searchText = lineEdit()->text();
+    QStringList newList = m_stringListModel->stringList();
+    if (newList.contains(searchText))
+        newList.removeAt(newList.indexOf(searchText));
+    newList.prepend(searchText);
+    if (newList.size() >= m_maxSavedSearches)
+        newList.removeLast();
+
+    QWebSettings *globalSettings = QWebSettings::globalSettings();
+    if (!globalSettings->testAttribute(QWebSettings::PrivateBrowsingEnabled)) {
+        m_stringListModel->setStringList(newList);
+        m_autosaver->changeOccurred();
+    }
+
+    QUrl url(QLatin1String("http://www.google.com/search"));
+    url.addQueryItem(QLatin1String("q"), searchText);
+    url.addQueryItem(QLatin1String("ie"), QLatin1String("UTF-8"));
+    url.addQueryItem(QLatin1String("oe"), QLatin1String("UTF-8"));
+    url.addQueryItem(QLatin1String("client"), QLatin1String("qtdemobrowser"));
+    emit search(url);
+}
+
+void ToolbarSearch::aboutToShowMenu()
+{
+    lineEdit()->selectAll();
+    QMenu *m = menu();
+    m->clear();
+    QStringList list = m_stringListModel->stringList();
+    if (list.isEmpty()) {
+        m->addAction(tr("No Recent Searches"));
+        return;
+    }
+
+    QAction *recent = m->addAction(tr("Recent Searches"));
+    recent->setEnabled(false);
+    for (int i = 0; i < list.count(); ++i) {
+        QString text = list.at(i);
+        m->addAction(text)->setData(text);
+    }
+    m->addSeparator();
+    m->addAction(tr("Clear Recent Searches"), this, SLOT(clear()));
+}
+
+void ToolbarSearch::triggeredMenuAction(QAction *action)
+{
+    QVariant v = action->data();
+    if (v.canConvert<QString>()) {
+        QString text = v.toString();
+        lineEdit()->setText(text);
+        searchNow();
+    }
+}
+
+void ToolbarSearch::clear()
+{
+    m_stringListModel->setStringList(QStringList());
+    m_autosaver->changeOccurred();;
+}
+
diff --git a/examples/gestures/browser/toolbarsearch.h b/examples/gestures/browser/toolbarsearch.h
new file mode 100644
index 0000000..1826d84
--- /dev/null
+++ b/examples/gestures/browser/toolbarsearch.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef TOOLBARSEARCH_H
+#define TOOLBARSEARCH_H
+
+#include "searchlineedit.h"
+
+QT_BEGIN_NAMESPACE
+class QUrl;
+class QAction;
+class QStringListModel;
+QT_END_NAMESPACE
+
+class AutoSaver;
+
+class ToolbarSearch : public SearchLineEdit
+{
+    Q_OBJECT
+
+signals:
+    void search(const QUrl &url);
+
+public:
+    ToolbarSearch(QWidget *parent = 0);
+    ~ToolbarSearch();
+
+public slots:
+    void clear();
+    void searchNow();
+
+private slots:
+    void save();
+    void aboutToShowMenu();
+    void triggeredMenuAction(QAction *action);
+
+private:
+    void load();
+
+    AutoSaver *m_autosaver;
+    int m_maxSavedSearches;
+    QStringListModel *m_stringListModel;
+};
+
+#endif // TOOLBARSEARCH_H
+
diff --git a/examples/gestures/browser/urllineedit.cpp b/examples/gestures/browser/urllineedit.cpp
new file mode 100644
index 0000000..019ca8b
--- /dev/null
+++ b/examples/gestures/browser/urllineedit.cpp
@@ -0,0 +1,340 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "urllineedit.h"
+
+#include "browserapplication.h"
+#include "searchlineedit.h"
+#include "webview.h"
+
+#include <QtCore/QEvent>
+
+#include <QtGui/QApplication>
+#include <QtGui/QCompleter>
+#include <QtGui/QFocusEvent>
+#include <QtGui/QHBoxLayout>
+#include <QtGui/QLabel>
+#include <QtGui/QLineEdit>
+#include <QtGui/QPainter>
+#include <QtGui/QStyle>
+#include <QtGui/QStyleOptionFrameV2>
+
+#include <QtCore/QDebug>
+
+ExLineEdit::ExLineEdit(QWidget *parent)
+    : QWidget(parent)
+    , m_leftWidget(0)
+    , m_lineEdit(new QLineEdit(this))
+    , m_clearButton(0)
+{
+    setFocusPolicy(m_lineEdit->focusPolicy());
+    setAttribute(Qt::WA_InputMethodEnabled);
+    setSizePolicy(m_lineEdit->sizePolicy());
+    setBackgroundRole(m_lineEdit->backgroundRole());
+    setMouseTracking(true);
+    setAcceptDrops(true);
+    setAttribute(Qt::WA_MacShowFocusRect, true);
+    QPalette p = m_lineEdit->palette();
+    setPalette(p);
+
+    // line edit
+    m_lineEdit->setFrame(false);
+    m_lineEdit->setFocusProxy(this);
+    m_lineEdit->setAttribute(Qt::WA_MacShowFocusRect, false);
+    QPalette clearPalette = m_lineEdit->palette();
+    clearPalette.setBrush(QPalette::Base, QBrush(Qt::transparent));
+    m_lineEdit->setPalette(clearPalette);
+
+    // clearButton
+    m_clearButton = new ClearButton(this);
+    connect(m_clearButton, SIGNAL(clicked()),
+            m_lineEdit, SLOT(clear()));
+    connect(m_lineEdit, SIGNAL(textChanged(const QString&)),
+            m_clearButton, SLOT(textChanged(const QString&)));
+}
+
+void ExLineEdit::setLeftWidget(QWidget *widget)
+{
+    m_leftWidget = widget;
+}
+
+QWidget *ExLineEdit::leftWidget() const
+{
+    return m_leftWidget;
+}
+
+void ExLineEdit::resizeEvent(QResizeEvent *event)
+{
+    Q_ASSERT(m_leftWidget);
+    updateGeometries();
+    QWidget::resizeEvent(event);
+}
+
+void ExLineEdit::updateGeometries()
+{
+    QStyleOptionFrameV2 panel;
+    initStyleOption(&panel);
+    QRect rect = style()->subElementRect(QStyle::SE_LineEditContents, &panel, this);
+
+    int height = rect.height();
+    int width = rect.width();
+
+    int m_leftWidgetHeight = m_leftWidget->height();
+    m_leftWidget->setGeometry(rect.x() + 2,          rect.y() + (height - m_leftWidgetHeight)/2,
+                              m_leftWidget->width(), m_leftWidget->height());
+
+    int clearButtonWidth = this->height();
+    m_lineEdit->setGeometry(m_leftWidget->x() + m_leftWidget->width(),        0,
+                            width - clearButtonWidth - m_leftWidget->width(), this->height());
+
+    m_clearButton->setGeometry(this->width() - clearButtonWidth, 0,
+                               clearButtonWidth, this->height());
+}
+
+void ExLineEdit::initStyleOption(QStyleOptionFrameV2 *option) const
+{
+    option->initFrom(this);
+    option->rect = contentsRect();
+    option->lineWidth = style()->pixelMetric(QStyle::PM_DefaultFrameWidth, option, this);
+    option->midLineWidth = 0;
+    option->state |= QStyle::State_Sunken;
+    if (m_lineEdit->isReadOnly())
+        option->state |= QStyle::State_ReadOnly;
+#ifdef QT_KEYPAD_NAVIGATION
+    if (hasEditFocus())
+        option->state |= QStyle::State_HasEditFocus;
+#endif
+    option->features = QStyleOptionFrameV2::None;
+}
+
+QSize ExLineEdit::sizeHint() const
+{
+    m_lineEdit->setFrame(true);
+    QSize size = m_lineEdit->sizeHint();
+    m_lineEdit->setFrame(false);
+    return size;
+}
+
+void ExLineEdit::focusInEvent(QFocusEvent *event)
+{
+    m_lineEdit->event(event);
+    QWidget::focusInEvent(event);
+}
+
+void ExLineEdit::focusOutEvent(QFocusEvent *event)
+{
+    m_lineEdit->event(event);
+
+    if (m_lineEdit->completer()) {
+        connect(m_lineEdit->completer(), SIGNAL(activated(QString)),
+                         m_lineEdit, SLOT(setText(QString)));
+        connect(m_lineEdit->completer(), SIGNAL(highlighted(QString)),
+                         m_lineEdit, SLOT(_q_completionHighlighted(QString)));
+    }
+    QWidget::focusOutEvent(event);
+}
+
+void ExLineEdit::keyPressEvent(QKeyEvent *event)
+{
+    m_lineEdit->event(event);
+}
+
+bool ExLineEdit::event(QEvent *event)
+{
+    if (event->type() == QEvent::ShortcutOverride)
+        return m_lineEdit->event(event);
+    return QWidget::event(event);
+}
+
+void ExLineEdit::paintEvent(QPaintEvent *)
+{
+    QPainter p(this);
+    QStyleOptionFrameV2 panel;
+    initStyleOption(&panel);
+    style()->drawPrimitive(QStyle::PE_PanelLineEdit, &panel, &p, this);
+}
+
+QVariant ExLineEdit::inputMethodQuery(Qt::InputMethodQuery property) const
+{
+    return m_lineEdit->inputMethodQuery(property);
+}
+
+void ExLineEdit::inputMethodEvent(QInputMethodEvent *e)
+{
+    m_lineEdit->event(e);
+}
+
+
+class UrlIconLabel : public QLabel
+{
+
+public:
+    UrlIconLabel(QWidget *parent);
+
+    WebView *m_webView;
+
+protected:
+    void mousePressEvent(QMouseEvent *event);
+    void mouseMoveEvent(QMouseEvent *event);
+
+private:
+    QPoint m_dragStartPos;
+
+};
+
+UrlIconLabel::UrlIconLabel(QWidget *parent)
+    : QLabel(parent)
+    , m_webView(0)
+{
+    setMinimumWidth(16);
+    setMinimumHeight(16);
+}
+
+void UrlIconLabel::mousePressEvent(QMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+        m_dragStartPos = event->pos();
+    QLabel::mousePressEvent(event);
+}
+
+void UrlIconLabel::mouseMoveEvent(QMouseEvent *event)
+{
+    if (event->buttons() == Qt::LeftButton
+        && (event->pos() - m_dragStartPos).manhattanLength() > QApplication::startDragDistance()
+         && m_webView) {
+        QDrag *drag = new QDrag(this);
+        QMimeData *mimeData = new QMimeData;
+        mimeData->setText(QString::fromUtf8(m_webView->url().toEncoded()));
+        QList<QUrl> urls;
+        urls.append(m_webView->url());
+        mimeData->setUrls(urls);
+        drag->setMimeData(mimeData);
+        drag->exec();
+    }
+}
+
+UrlLineEdit::UrlLineEdit(QWidget *parent)
+    : ExLineEdit(parent)
+    , m_webView(0)
+    , m_iconLabel(0)
+{
+    // icon
+    m_iconLabel = new UrlIconLabel(this);
+    m_iconLabel->resize(16, 16);
+    setLeftWidget(m_iconLabel);
+    m_defaultBaseColor = palette().color(QPalette::Base);
+
+    webViewIconChanged();
+}
+
+void UrlLineEdit::setWebView(WebView *webView)
+{
+    Q_ASSERT(!m_webView);
+    m_webView = webView;
+    m_iconLabel->m_webView = webView;
+    connect(webView, SIGNAL(urlChanged(const QUrl &)),
+        this, SLOT(webViewUrlChanged(const QUrl &)));
+    connect(webView, SIGNAL(loadFinished(bool)),
+        this, SLOT(webViewIconChanged()));
+    connect(webView, SIGNAL(iconChanged()),
+        this, SLOT(webViewIconChanged()));
+    connect(webView, SIGNAL(loadProgress(int)),
+        this, SLOT(update()));
+}
+
+void UrlLineEdit::webViewUrlChanged(const QUrl &url)
+{
+    m_lineEdit->setText(QString::fromUtf8(url.toEncoded()));
+    m_lineEdit->setCursorPosition(0);
+}
+
+void UrlLineEdit::webViewIconChanged()
+{
+    QUrl url = (m_webView)  ? m_webView->url() : QUrl();
+    QIcon icon = BrowserApplication::instance()->icon(url);
+    QPixmap pixmap(icon.pixmap(16, 16));
+    m_iconLabel->setPixmap(pixmap);
+}
+
+QLinearGradient UrlLineEdit::generateGradient(const QColor &color) const
+{
+    QLinearGradient gradient(0, 0, 0, height());
+    gradient.setColorAt(0, m_defaultBaseColor);
+    gradient.setColorAt(0.15, color.lighter(120));
+    gradient.setColorAt(0.5, color);
+    gradient.setColorAt(0.85, color.lighter(120));
+    gradient.setColorAt(1, m_defaultBaseColor);
+    return gradient;
+}
+
+void UrlLineEdit::focusOutEvent(QFocusEvent *event)
+{
+    if (m_lineEdit->text().isEmpty() && m_webView)
+        m_lineEdit->setText(QString::fromUtf8(m_webView->url().toEncoded()));
+    ExLineEdit::focusOutEvent(event);
+}
+
+void UrlLineEdit::paintEvent(QPaintEvent *event)
+{
+    QPalette p = palette();
+    if (m_webView && m_webView->url().scheme() == QLatin1String("https")) {
+        QColor lightYellow(248, 248, 210);
+        p.setBrush(QPalette::Base, generateGradient(lightYellow));
+    } else {
+        p.setBrush(QPalette::Base, m_defaultBaseColor);
+    }
+    setPalette(p);
+    ExLineEdit::paintEvent(event);
+
+    QPainter painter(this);
+    QStyleOptionFrameV2 panel;
+    initStyleOption(&panel);
+    QRect backgroundRect = style()->subElementRect(QStyle::SE_LineEditContents, &panel, this);
+    if (m_webView && !hasFocus()) {
+        int progress = m_webView->progress();
+        QColor loadingColor = QColor(116, 192, 250);
+        painter.setBrush(generateGradient(loadingColor));
+        painter.setPen(Qt::transparent);
+        int mid = backgroundRect.width() / 100 * progress;
+        QRect progressRect(backgroundRect.x(), backgroundRect.y(), mid, backgroundRect.height());
+        painter.drawRect(progressRect);
+    }
+}
diff --git a/examples/gestures/browser/urllineedit.h b/examples/gestures/browser/urllineedit.h
new file mode 100644
index 0000000..ee05d3d
--- /dev/null
+++ b/examples/gestures/browser/urllineedit.h
@@ -0,0 +1,115 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef URLLINEEDIT_H
+#define URLLINEEDIT_H
+
+#include <QtCore/QUrl>
+#include <QtGui/QWidget>
+#include <QtGui/QStyleOptionFrame>
+
+QT_BEGIN_NAMESPACE
+class QLineEdit;
+QT_END_NAMESPACE
+
+class ClearButton;
+class ExLineEdit : public QWidget
+{
+    Q_OBJECT
+
+public:
+    ExLineEdit(QWidget *parent = 0);
+
+    inline QLineEdit *lineEdit() const { return m_lineEdit; }
+
+    void setLeftWidget(QWidget *widget);
+    QWidget *leftWidget() const;
+
+    QSize sizeHint() const;
+
+    QVariant inputMethodQuery(Qt::InputMethodQuery property) const;
+protected:
+    void focusInEvent(QFocusEvent *event);
+    void focusOutEvent(QFocusEvent *event);
+    void keyPressEvent(QKeyEvent *event);
+    void paintEvent(QPaintEvent *event);
+    void resizeEvent(QResizeEvent *event);
+    void inputMethodEvent(QInputMethodEvent *e);
+    bool event(QEvent *event);
+
+protected:
+    void updateGeometries();
+    void initStyleOption(QStyleOptionFrameV2 *option) const;
+
+    QWidget *m_leftWidget;
+    QLineEdit *m_lineEdit;
+    ClearButton *m_clearButton;
+};
+
+class UrlIconLabel;
+class WebView;
+class UrlLineEdit : public ExLineEdit
+{
+    Q_OBJECT
+
+public:
+    UrlLineEdit(QWidget *parent = 0);
+    void setWebView(WebView *webView);
+
+protected:
+    void paintEvent(QPaintEvent *event);
+    void focusOutEvent(QFocusEvent *event);
+
+private slots:
+    void webViewUrlChanged(const QUrl &url);
+    void webViewIconChanged();
+
+private:
+    QLinearGradient generateGradient(const QColor &color) const;
+    WebView *m_webView;
+    UrlIconLabel *m_iconLabel;
+    QColor m_defaultBaseColor;
+
+};
+
+
+#endif // URLLINEEDIT_H
+
diff --git a/examples/gestures/browser/webview.cpp b/examples/gestures/browser/webview.cpp
new file mode 100644
index 0000000..38fb43d
--- /dev/null
+++ b/examples/gestures/browser/webview.cpp
@@ -0,0 +1,325 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "browserapplication.h"
+#include "browsermainwindow.h"
+#include "cookiejar.h"
+#include "downloadmanager.h"
+#include "networkaccessmanager.h"
+#include "tabwidget.h"
+#include "webview.h"
+
+#include <QtGui/QClipboard>
+#include <QtGui/QMenu>
+#include <QtGui/QMessageBox>
+#include <QtGui/QMouseEvent>
+
+#include <QtWebKit/QWebHitTestResult>
+
+#include <QtUiTools/QUiLoader>
+
+#include <QtCore/QDebug>
+#include <QtCore/QBuffer>
+
+WebPage::WebPage(QObject *parent)
+    : QWebPage(parent)
+    , m_keyboardModifiers(Qt::NoModifier)
+    , m_pressedButtons(Qt::NoButton)
+    , m_openInNewTab(false)
+{
+    setNetworkAccessManager(BrowserApplication::networkAccessManager());
+    connect(this, SIGNAL(unsupportedContent(QNetworkReply *)),
+            this, SLOT(handleUnsupportedContent(QNetworkReply *)));
+}
+
+BrowserMainWindow *WebPage::mainWindow()
+{
+    QObject *w = this->parent();
+    while (w) {
+        if (BrowserMainWindow *mw = qobject_cast<BrowserMainWindow*>(w))
+            return mw;
+        w = w->parent();
+    }
+    return BrowserApplication::instance()->mainWindow();
+}
+
+bool WebPage::acceptNavigationRequest(QWebFrame *frame, const QNetworkRequest &request, NavigationType type)
+{
+    // ctrl open in new tab
+    // ctrl-shift open in new tab and select
+    // ctrl-alt open in new window
+    if (type == QWebPage::NavigationTypeLinkClicked
+        && (m_keyboardModifiers & Qt::ControlModifier
+            || m_pressedButtons == Qt::MidButton)) {
+        bool newWindow = (m_keyboardModifiers & Qt::AltModifier);
+        WebView *webView;
+        if (newWindow) {
+            BrowserApplication::instance()->newMainWindow();
+            BrowserMainWindow *newMainWindow = BrowserApplication::instance()->mainWindow();
+            webView = newMainWindow->currentTab();
+            newMainWindow->raise();
+            newMainWindow->activateWindow();
+            webView->setFocus();
+        } else {
+            bool selectNewTab = (m_keyboardModifiers & Qt::ShiftModifier);
+            webView = mainWindow()->tabWidget()->newTab(selectNewTab);
+        }
+        webView->load(request);
+        m_keyboardModifiers = Qt::NoModifier;
+        m_pressedButtons = Qt::NoButton;
+        return false;
+    }
+    if (frame == mainFrame()) {
+        m_loadingUrl = request.url();
+        emit loadingUrl(m_loadingUrl);
+    }
+    return QWebPage::acceptNavigationRequest(frame, request, type);
+}
+
+QWebPage *WebPage::createWindow(QWebPage::WebWindowType type)
+{
+    Q_UNUSED(type);
+    if (m_keyboardModifiers & Qt::ControlModifier || m_pressedButtons == Qt::MidButton)
+        m_openInNewTab = true;
+    if (m_openInNewTab) {
+        m_openInNewTab = false;
+        return mainWindow()->tabWidget()->newTab()->page();
+    }
+    BrowserApplication::instance()->newMainWindow();
+    BrowserMainWindow *mainWindow = BrowserApplication::instance()->mainWindow();
+    return mainWindow->currentTab()->page();
+}
+
+#if !defined(QT_NO_UITOOLS)
+QObject *WebPage::createPlugin(const QString &classId, const QUrl &url, const QStringList &paramNames, const QStringList &paramValues)
+{
+    Q_UNUSED(url);
+    Q_UNUSED(paramNames);
+    Q_UNUSED(paramValues);
+    QUiLoader loader;
+    return loader.createWidget(classId, view());
+}
+#endif // !defined(QT_NO_UITOOLS)
+
+void WebPage::handleUnsupportedContent(QNetworkReply *reply)
+{
+    if (reply->error() == QNetworkReply::NoError) {
+        BrowserApplication::downloadManager()->handleUnsupportedContent(reply);
+        return;
+    }
+
+    QFile file(QLatin1String(":/notfound.html"));
+    bool isOpened = file.open(QIODevice::ReadOnly);
+    Q_ASSERT(isOpened);
+    QString title = tr("Error loading page: %1").arg(reply->url().toString());
+    QString html = QString(QLatin1String(file.readAll()))
+                        .arg(title)
+                        .arg(reply->errorString())
+                        .arg(reply->url().toString());
+
+    QBuffer imageBuffer;
+    imageBuffer.open(QBuffer::ReadWrite);
+    QIcon icon = view()->style()->standardIcon(QStyle::SP_MessageBoxWarning, 0, view());
+    QPixmap pixmap = icon.pixmap(QSize(32,32));
+    if (pixmap.save(&imageBuffer, "PNG")) {
+        html.replace(QLatin1String("IMAGE_BINARY_DATA_HERE"),
+                     QString(QLatin1String(imageBuffer.buffer().toBase64())));
+    }
+
+    QList<QWebFrame*> frames;
+    frames.append(mainFrame());
+    while (!frames.isEmpty()) {
+        QWebFrame *frame = frames.takeFirst();
+        if (frame->url() == reply->url()) {
+            frame->setHtml(html, reply->url());
+            return;
+        }
+        QList<QWebFrame *> children = frame->childFrames();
+        foreach(QWebFrame *frame, children)
+            frames.append(frame);
+    }
+    if (m_loadingUrl == reply->url()) {
+        mainFrame()->setHtml(html, reply->url());
+    }
+}
+
+
+WebView::WebView(QWidget* parent)
+    : QWebView(parent)
+    , m_progress(0)
+    , m_page(new WebPage(this))
+{
+    grabGesture(Qt::PanGesture);
+    setPage(m_page);
+    connect(page(), SIGNAL(statusBarMessage(const QString&)),
+            SLOT(setStatusBarText(const QString&)));
+    connect(this, SIGNAL(loadProgress(int)),
+            this, SLOT(setProgress(int)));
+    connect(this, SIGNAL(loadFinished(bool)),
+            this, SLOT(loadFinished()));
+    connect(page(), SIGNAL(loadingUrl(const QUrl&)),
+            this, SIGNAL(urlChanged(const QUrl &)));
+    connect(page(), SIGNAL(downloadRequested(const QNetworkRequest &)),
+            this, SLOT(downloadRequested(const QNetworkRequest &)));
+    page()->setForwardUnsupportedContent(true);
+
+}
+
+void WebView::contextMenuEvent(QContextMenuEvent *event)
+{
+    QWebHitTestResult r = page()->mainFrame()->hitTestContent(event->pos());
+    if (!r.linkUrl().isEmpty()) {
+        QMenu menu(this);
+        menu.addAction(pageAction(QWebPage::OpenLinkInNewWindow));
+        menu.addAction(tr("Open in New Tab"), this, SLOT(openLinkInNewTab()));
+        menu.addSeparator();
+        menu.addAction(pageAction(QWebPage::DownloadLinkToDisk));
+        // Add link to bookmarks...
+        menu.addSeparator();
+        menu.addAction(pageAction(QWebPage::CopyLinkToClipboard));
+        if (page()->settings()->testAttribute(QWebSettings::DeveloperExtrasEnabled))
+            menu.addAction(pageAction(QWebPage::InspectElement));
+        menu.exec(mapToGlobal(event->pos()));
+        return;
+    }
+    QWebView::contextMenuEvent(event);
+}
+
+void WebView::wheelEvent(QWheelEvent *event)
+{
+    if (QApplication::keyboardModifiers() & Qt::ControlModifier) {
+        int numDegrees = event->delta() / 8;
+        int numSteps = numDegrees / 15;
+        setTextSizeMultiplier(textSizeMultiplier() + numSteps * 0.1);
+        event->accept();
+        return;
+    }
+    QWebView::wheelEvent(event);
+}
+
+void WebView::openLinkInNewTab()
+{
+    m_page->m_openInNewTab = true;
+    pageAction(QWebPage::OpenLinkInNewWindow)->trigger();
+}
+
+void WebView::setProgress(int progress)
+{
+    m_progress = progress;
+}
+
+void WebView::loadFinished()
+{
+    if (100 != m_progress) {
+        qWarning() << "Recieved finished signal while progress is still:" << progress()
+                   << "Url:" << url();
+    }
+    m_progress = 0;
+}
+
+void WebView::loadUrl(const QUrl &url)
+{
+    m_initialUrl = url;
+    load(url);
+}
+
+QString WebView::lastStatusBarText() const
+{
+    return m_statusBarText;
+}
+
+QUrl WebView::url() const
+{
+    QUrl url = QWebView::url();
+    if (!url.isEmpty())
+        return url;
+
+    return m_initialUrl;
+}
+
+void WebView::mousePressEvent(QMouseEvent *event)
+{
+    m_page->m_pressedButtons = event->buttons();
+    m_page->m_keyboardModifiers = event->modifiers();
+    QWebView::mousePressEvent(event);
+}
+
+void WebView::mouseReleaseEvent(QMouseEvent *event)
+{
+    QWebView::mouseReleaseEvent(event);
+    if (!event->isAccepted() && (m_page->m_pressedButtons & Qt::MidButton)) {
+        QUrl url(QApplication::clipboard()->text(QClipboard::Selection));
+        if (!url.isEmpty() && url.isValid() && !url.scheme().isEmpty()) {
+            setUrl(url);
+        }
+    }
+}
+
+void WebView::setStatusBarText(const QString &string)
+{
+    m_statusBarText = string;
+}
+
+void WebView::downloadRequested(const QNetworkRequest &request)
+{
+    BrowserApplication::downloadManager()->download(request);
+}
+
+bool WebView::event(QEvent *event)
+{
+    if (event->type() == QEvent::Gesture)
+    {
+        gestureEvent(static_cast<QGestureEvent*>(event));
+        return true;
+    }
+    return QWebView::event(event);
+}
+
+void WebView::gestureEvent(QGestureEvent *event)
+{
+    if (const QGesture *g = event->gesture(Qt::PanGesture)) {
+        if (QWebFrame *frame = page()->mainFrame()) {
+            QPoint offset = g->pos() - g->lastPos();
+            frame->setScrollPosition(frame->scrollPosition() - offset);
+        }
+        event->accept();
+    }
+}
diff --git a/examples/gestures/browser/webview.h b/examples/gestures/browser/webview.h
new file mode 100644
index 0000000..037d117
--- /dev/null
+++ b/examples/gestures/browser/webview.h
@@ -0,0 +1,121 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef WEBVIEW_H
+#define WEBVIEW_H
+
+#include <QtWebKit/QWebView>
+
+QT_BEGIN_NAMESPACE
+class QAuthenticator;
+class QMouseEvent;
+class QNetworkProxy;
+class QNetworkReply;
+class QSslError;
+QT_END_NAMESPACE
+
+class BrowserMainWindow;
+class WebPage : public QWebPage {
+    Q_OBJECT
+
+signals:
+    void loadingUrl(const QUrl &url);
+
+public:
+    WebPage(QObject *parent = 0);
+    BrowserMainWindow *mainWindow();
+
+protected:
+    bool acceptNavigationRequest(QWebFrame *frame, const QNetworkRequest &request, NavigationType type);
+    QWebPage *createWindow(QWebPage::WebWindowType type);
+#if !defined(QT_NO_UITOOLS)
+    QObject *createPlugin(const QString &classId, const QUrl &url, const QStringList &paramNames, const QStringList &paramValues);
+#endif
+
+private slots:
+    void handleUnsupportedContent(QNetworkReply *reply);
+
+private:
+    friend class WebView;
+
+    // set the webview mousepressedevent
+    Qt::KeyboardModifiers m_keyboardModifiers;
+    Qt::MouseButtons m_pressedButtons;
+    bool m_openInNewTab;
+    QUrl m_loadingUrl;
+};
+
+class WebView : public QWebView {
+    Q_OBJECT
+
+public:
+    WebView(QWidget *parent = 0);
+    WebPage *webPage() const { return m_page; }
+
+    void loadUrl(const QUrl &url);
+    QUrl url() const;
+
+    QString lastStatusBarText() const;
+    inline int progress() const { return m_progress; }
+
+protected:
+    bool event(QEvent *event);
+    void gestureEvent(QGestureEvent *event);
+    void mousePressEvent(QMouseEvent *event);
+    void mouseReleaseEvent(QMouseEvent *event);
+    void contextMenuEvent(QContextMenuEvent *event);
+    void wheelEvent(QWheelEvent *event);
+
+private slots:
+    void setProgress(int progress);
+    void loadFinished();
+    void setStatusBarText(const QString &string);
+    void downloadRequested(const QNetworkRequest &request);
+    void openLinkInNewTab();
+
+private:
+    QString m_statusBarText;
+    QUrl m_initialUrl;
+    int m_progress;
+    WebPage *m_page;
+};
+
+#endif
diff --git a/examples/gestures/browser/xbel.cpp b/examples/gestures/browser/xbel.cpp
new file mode 100644
index 0000000..c1a528d
--- /dev/null
+++ b/examples/gestures/browser/xbel.cpp
@@ -0,0 +1,320 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "xbel.h"
+
+#include <QtCore/QFile>
+
+BookmarkNode::BookmarkNode(BookmarkNode::Type type, BookmarkNode *parent) :
+     expanded(false)
+   , m_parent(parent)
+   , m_type(type)
+{
+    if (parent)
+        parent->add(this);
+}
+
+BookmarkNode::~BookmarkNode()
+{
+    if (m_parent)
+        m_parent->remove(this);
+    qDeleteAll(m_children);
+    m_parent = 0;
+    m_type = BookmarkNode::Root;
+}
+
+bool BookmarkNode::operator==(const BookmarkNode &other)
+{
+    if (url != other.url
+        || title != other.title
+        || desc != other.desc
+        || expanded != other.expanded
+        || m_type != other.m_type
+        || m_children.count() != other.m_children.count())
+        return false;
+
+    for (int i = 0; i < m_children.count(); ++i)
+        if (!((*(m_children[i])) == (*(other.m_children[i]))))
+            return false;
+    return true;
+}
+
+BookmarkNode::Type BookmarkNode::type() const
+{
+    return m_type;
+}
+
+void BookmarkNode::setType(Type type)
+{
+    m_type = type;
+}
+
+QList<BookmarkNode *> BookmarkNode::children() const
+{
+    return m_children;
+}
+
+BookmarkNode *BookmarkNode::parent() const
+{
+    return m_parent;
+}
+
+void BookmarkNode::add(BookmarkNode *child, int offset)
+{
+    Q_ASSERT(child->m_type != Root);
+    if (child->m_parent)
+        child->m_parent->remove(child);
+    child->m_parent = this;
+    if (-1 == offset)
+        offset = m_children.size();
+    m_children.insert(offset, child);
+}
+
+void BookmarkNode::remove(BookmarkNode *child)
+{
+    child->m_parent = 0;
+    m_children.removeAll(child);
+}
+
+
+XbelReader::XbelReader()
+{
+}
+
+BookmarkNode *XbelReader::read(const QString &fileName)
+{
+    QFile file(fileName);
+    if (!file.exists()) {
+        return new BookmarkNode(BookmarkNode::Root);
+    }
+    file.open(QFile::ReadOnly);
+    return read(&file);
+}
+
+BookmarkNode *XbelReader::read(QIODevice *device)
+{
+    BookmarkNode *root = new BookmarkNode(BookmarkNode::Root);
+    setDevice(device);
+    while (!atEnd()) {
+        readNext();
+        if (isStartElement()) {
+            QString version = attributes().value(QLatin1String("version")).toString();
+            if (name() == QLatin1String("xbel")
+                && (version.isEmpty() || version == QLatin1String("1.0"))) {
+                readXBEL(root);
+            } else {
+                raiseError(QObject::tr("The file is not an XBEL version 1.0 file."));
+            }
+        }
+    }
+    return root;
+}
+
+void XbelReader::readXBEL(BookmarkNode *parent)
+{
+    Q_ASSERT(isStartElement() && name() == QLatin1String("xbel"));
+
+    while (!atEnd()) {
+        readNext();
+        if (isEndElement())
+            break;
+
+        if (isStartElement()) {
+            if (name() == QLatin1String("folder"))
+                readFolder(parent);
+            else if (name() == QLatin1String("bookmark"))
+                readBookmarkNode(parent);
+            else if (name() == QLatin1String("separator"))
+                readSeparator(parent);
+            else
+                skipUnknownElement();
+        }
+    }
+}
+
+void XbelReader::readFolder(BookmarkNode *parent)
+{
+    Q_ASSERT(isStartElement() && name() == QLatin1String("folder"));
+
+    BookmarkNode *folder = new BookmarkNode(BookmarkNode::Folder, parent);
+    folder->expanded = (attributes().value(QLatin1String("folded")) == QLatin1String("no"));
+
+    while (!atEnd()) {
+        readNext();
+
+        if (isEndElement())
+            break;
+
+        if (isStartElement()) {
+            if (name() == QLatin1String("title"))
+                readTitle(folder);
+            else if (name() == QLatin1String("desc"))
+                readDescription(folder);
+            else if (name() == QLatin1String("folder"))
+                readFolder(folder);
+            else if (name() == QLatin1String("bookmark"))
+                readBookmarkNode(folder);
+            else if (name() == QLatin1String("separator"))
+                readSeparator(folder);
+            else
+                skipUnknownElement();
+        }
+    }
+}
+
+void XbelReader::readTitle(BookmarkNode *parent)
+{
+    Q_ASSERT(isStartElement() && name() == QLatin1String("title"));
+    parent->title = readElementText();
+}
+
+void XbelReader::readDescription(BookmarkNode *parent)
+{
+    Q_ASSERT(isStartElement() && name() == QLatin1String("desc"));
+    parent->desc = readElementText();
+}
+
+void XbelReader::readSeparator(BookmarkNode *parent)
+{
+    new BookmarkNode(BookmarkNode::Separator, parent);
+    // empty elements have a start and end element
+    readNext();
+}
+
+void XbelReader::readBookmarkNode(BookmarkNode *parent)
+{
+    Q_ASSERT(isStartElement() && name() == QLatin1String("bookmark"));
+    BookmarkNode *bookmark = new BookmarkNode(BookmarkNode::Bookmark, parent);
+    bookmark->url = attributes().value(QLatin1String("href")).toString();
+    while (!atEnd()) {
+        readNext();
+        if (isEndElement())
+            break;
+
+        if (isStartElement()) {
+            if (name() == QLatin1String("title"))
+                readTitle(bookmark);
+            else if (name() == QLatin1String("desc"))
+                readDescription(bookmark);
+            else
+                skipUnknownElement();
+        }
+    }
+    if (bookmark->title.isEmpty())
+        bookmark->title = QObject::tr("Unknown title");
+}
+
+void XbelReader::skipUnknownElement()
+{
+    Q_ASSERT(isStartElement());
+
+    while (!atEnd()) {
+        readNext();
+
+        if (isEndElement())
+            break;
+
+        if (isStartElement())
+            skipUnknownElement();
+    }
+}
+
+
+XbelWriter::XbelWriter()
+{
+    setAutoFormatting(true);
+}
+
+bool XbelWriter::write(const QString &fileName, const BookmarkNode *root)
+{
+    QFile file(fileName);
+    if (!root || !file.open(QFile::WriteOnly))
+        return false;
+    return write(&file, root);
+}
+
+bool XbelWriter::write(QIODevice *device, const BookmarkNode *root)
+{
+    setDevice(device);
+
+    writeStartDocument();
+    writeDTD(QLatin1String("<!DOCTYPE xbel>"));
+    writeStartElement(QLatin1String("xbel"));
+    writeAttribute(QLatin1String("version"), QLatin1String("1.0"));
+    if (root->type() == BookmarkNode::Root) {
+        for (int i = 0; i < root->children().count(); ++i)
+            writeItem(root->children().at(i));
+    } else {
+        writeItem(root);
+    }
+
+    writeEndDocument();
+    return true;
+}
+
+void XbelWriter::writeItem(const BookmarkNode *parent)
+{
+    switch (parent->type()) {
+    case BookmarkNode::Folder:
+        writeStartElement(QLatin1String("folder"));
+        writeAttribute(QLatin1String("folded"), parent->expanded ? QLatin1String("no") : QLatin1String("yes"));
+        writeTextElement(QLatin1String("title"), parent->title);
+        for (int i = 0; i < parent->children().count(); ++i)
+            writeItem(parent->children().at(i));
+        writeEndElement();
+        break;
+    case BookmarkNode::Bookmark:
+        writeStartElement(QLatin1String("bookmark"));
+        if (!parent->url.isEmpty())
+            writeAttribute(QLatin1String("href"), parent->url);
+        writeTextElement(QLatin1String("title"), parent->title);
+        if (!parent->desc.isEmpty())
+            writeAttribute(QLatin1String("desc"), parent->desc);
+        writeEndElement();
+        break;
+    case BookmarkNode::Separator:
+        writeEmptyElement(QLatin1String("separator"));
+        break;
+    default:
+        break;
+    }
+}
+
diff --git a/examples/gestures/browser/xbel.h b/examples/gestures/browser/xbel.h
new file mode 100644
index 0000000..7b8b017
--- /dev/null
+++ b/examples/gestures/browser/xbel.h
@@ -0,0 +1,113 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the $MODULE$ of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial Usage
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef XBEL_H
+#define XBEL_H
+
+#include <QtCore/QXmlStreamReader>
+#include <QtCore/QDateTime>
+
+class BookmarkNode
+{
+public:
+    enum Type {
+        Root,
+        Folder,
+        Bookmark,
+        Separator
+    };
+
+    BookmarkNode(Type type = Root, BookmarkNode *parent = 0);
+    ~BookmarkNode();
+    bool operator==(const BookmarkNode &other);
+
+    Type type() const;
+    void setType(Type type);
+    QList<BookmarkNode *> children() const;
+    BookmarkNode *parent() const;
+
+    void add(BookmarkNode *child, int offset = -1);
+    void remove(BookmarkNode *child);
+
+    QString url;
+    QString title;
+    QString desc;
+    bool expanded;
+
+private:
+    BookmarkNode *m_parent;
+    Type m_type;
+    QList<BookmarkNode *> m_children;
+
+};
+
+class XbelReader : public QXmlStreamReader
+{
+public:
+    XbelReader();
+    BookmarkNode *read(const QString &fileName);
+    BookmarkNode *read(QIODevice *device);
+
+private:
+    void skipUnknownElement();
+    void readXBEL(BookmarkNode *parent);
+    void readTitle(BookmarkNode *parent);
+    void readDescription(BookmarkNode *parent);
+    void readSeparator(BookmarkNode *parent);
+    void readFolder(BookmarkNode *parent);
+    void readBookmarkNode(BookmarkNode *parent);
+};
+
+#include <QtCore/QXmlStreamWriter>
+
+class XbelWriter : public QXmlStreamWriter
+{
+public:
+    XbelWriter();
+    bool write(const QString &fileName, const BookmarkNode *root);
+    bool write(QIODevice *device, const BookmarkNode *root);
+
+private:
+    void writeItem(const BookmarkNode *parent);
+};
+
+#endif // XBEL_H
+