Rename the widget browser example demobrowser

The browser example already uses the name demobrowser internally, this
changes the external name to make it easier to refer to explicitly, and
avoid users thinking fancybrowser is the better example.

Change-Id: Ic093eb4881352b5f796bf565df01edb929aba39c
Reviewed-by: Joerg Bornemann <joerg.bornemann@theqtcompany.com>

1 files changed, 982 insertions, 0 deletions

diff --git a/examples/webenginewidgets/demobrowser/browsermainwindow.cpp b/examples/webenginewidgets/demobrowser/browsermainwindow.cpp
new file mode 100644
index 000000000..9595ca7ba
--- /dev/null
+++ b/examples/webenginewidgets/demobrowser/browsermainwindow.cpp
@@ -0,0 +1,982 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the demonstration applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** 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.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, 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.
+**
+**
+** $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 <QtWidgets/QDesktopWidget>
+#include <QtWidgets/QFileDialog>
+#include <QtWidgets/QPlainTextEdit>
+#include <QtPrintSupport/QPrintDialog>
+#include <QtPrintSupport/QPrintPreviewDialog>
+#include <QtPrintSupport/QPrinter>
+#include <QtWidgets/QMenuBar>
+#include <QtWidgets/QMessageBox>
+#include <QtWidgets/QStatusBar>
+#include <QtWidgets/QToolBar>
+#include <QtWidgets/QInputDialog>
+
+#include <QWebEngineHistory>
+#include <QWebEngineProfile>
+#include <QWebEngineSettings>
+
+#include <QtCore/QDebug>
+
+template<typename Arg, typename R, typename C>
+struct InvokeWrapper {
+    R *receiver;
+    void (C::*memberFun)(Arg);
+    void operator()(Arg result) {
+        (receiver->*memberFun)(result);
+    }
+};
+
+template<typename Arg, typename R, typename C>
+InvokeWrapper<Arg, R, C> invoke(R *receiver, void (C::*memberFun)(Arg))
+{
+    InvokeWrapper<Arg, R, C> wrapper = {receiver, memberFun};
+    return wrapper;
+}
+
+const char *BrowserMainWindow::defaultHome = "http://qt.io/";
+
+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)
+{
+    setToolButtonStyle(Qt::ToolButtonFollowStyle);
+    setAttribute(Qt::WA_DeleteOnClose, true);
+    statusBar()->setSizeGripEnabled(true);
+    setupMenu();
+    setupToolBar();
+
+    QWidget *centralWidget = new QWidget(this);
+    BookmarksModel *bookmarksModel = BrowserApplication::bookmarksManager()->bookmarksModel();
+    m_bookmarksToolbar = new BookmarksToolBar(bookmarksModel, this);
+    connect(m_bookmarksToolbar, SIGNAL(openUrl(QUrl)),
+            m_tabWidget, SLOT(loadUrlInCurrentTab(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_OS_OSX)
+    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(QString)),
+        this, SLOT(loadPage(QString)));
+    connect(m_tabWidget, SIGNAL(setCurrentTitle(QString)),
+        this, SLOT(slotUpdateWindowTitle(QString)));
+    connect(m_tabWidget, SIGNAL(showStatusBarMessage(QString)),
+            statusBar(), SLOT(showMessage(QString)));
+    connect(m_tabWidget, SIGNAL(linkHovered(QString)),
+            statusBar(), SLOT(showMessage(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(QRect)),
+            this, SLOT(geometryChangeRequested(QRect)));
+#if defined(QWEBENGINEPAGE_PRINTREQUESTED)
+    connect(m_tabWidget, SIGNAL(printRequested(QWebEngineFrame*)),
+            this, SLOT(printRequested(QWebEngineFrame*)));
+#endif
+    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_OS_OSX)
+    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::runScriptOnOpenViews(const QString &source)
+{
+    for (int i =0; i < tabWidget()->count(); ++i)
+        tabWidget()->webView(i)->page()->runJavaScript(source);
+}
+
+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();
+#if defined(QWEBENGINE_SAVE_AS_FILE)
+    fileMenu->addAction(tr("&Save As..."), this,
+                SLOT(slotFileSaveAs()), QKeySequence(QKeySequence::Save));
+    fileMenu->addSeparator();
+#endif
+    BookmarksManager *bookmarksManager = BrowserApplication::bookmarksManager();
+    fileMenu->addAction(tr("&Import Bookmarks..."), bookmarksManager, SLOT(importBookmarks()));
+    fileMenu->addAction(tr("&Export Bookmarks..."), bookmarksManager, SLOT(exportBookmarks()));
+    fileMenu->addSeparator();
+#if defined(QWEBENGINEPAGE_PRINT)
+    fileMenu->addAction(tr("P&rint Preview..."), this, SLOT(slotFilePrintPreview()));
+    fileMenu->addAction(tr("&Print..."), this, SLOT(slotFilePrint()), QKeySequence::Print);
+    fileMenu->addSeparator();
+#endif
+    QAction *action = fileMenu->addAction(tr("Private &Browsing..."), this, SLOT(slotPrivateBrowsing()));
+    action->setCheckable(true);
+    action->setChecked(BrowserApplication::instance()->privateBrowsing());
+    connect(BrowserApplication::instance(), SIGNAL(privateBrowsingChanged(bool)), action, SLOT(setChecked(bool)));
+    fileMenu->addSeparator();
+
+#if defined(Q_OS_OSX)
+    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, QWebEnginePage::Undo);
+    QAction *m_redo = editMenu->addAction(tr("&Redo"));
+    m_redo->setShortcuts(QKeySequence::Redo);
+    m_tabWidget->addWebAction(m_redo, QWebEnginePage::Redo);
+    editMenu->addSeparator();
+    QAction *m_cut = editMenu->addAction(tr("Cu&t"));
+    m_cut->setShortcuts(QKeySequence::Cut);
+    m_tabWidget->addWebAction(m_cut, QWebEnginePage::Cut);
+    QAction *m_copy = editMenu->addAction(tr("&Copy"));
+    m_copy->setShortcuts(QKeySequence::Copy);
+    m_tabWidget->addWebAction(m_copy, QWebEnginePage::Copy);
+    QAction *m_paste = editMenu->addAction(tr("&Paste"));
+    m_paste->setShortcuts(QKeySequence::Paste);
+    m_tabWidget->addWebAction(m_paste, QWebEnginePage::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, QWebEnginePage::Stop);
+
+    m_reload = viewMenu->addAction(tr("Reload Page"));
+    m_reload->setShortcuts(QKeySequence::Refresh);
+    m_tabWidget->addWebAction(m_reload, QWebEnginePage::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));
+
+    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(QUrl)),
+            m_tabWidget, SLOT(loadUrlInCurrentTab(QUrl)));
+    connect(historyMenu, SIGNAL(hovered(QString)), this,
+            SLOT(slotUpdateStatusbar(QString)));
+    historyMenu->setTitle(tr("Hi&story"));
+    menuBar()->addMenu(historyMenu);
+    QList<QAction*> historyActions;
+
+    m_historyBack = new QAction(tr("Back"), this);
+    m_tabWidget->addWebAction(m_historyBack, QWebEnginePage::Back);
+    m_historyBack->setShortcuts(QKeySequence::Back);
+    m_historyBack->setIconVisibleInMenu(false);
+    historyActions.append(m_historyBack);
+
+    m_historyForward = new QAction(tr("Forward"), this);
+    m_tabWidget->addWebAction(m_historyForward, QWebEnginePage::Forward);
+    m_historyForward->setShortcuts(QKeySequence::Forward);
+    m_historyForward->setIconVisibleInMenu(false);
+    historyActions.append(m_historyForward);
+
+    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));
+    historyActions.append(m_historyHome);
+
+#if defined(QWEBENGINEHISTORY_RESTORESESSION)
+    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_tabWidget->recentlyClosedTabsAction());
+    historyActions.append(m_restoreLastSession);
+#endif
+
+    historyMenu->setInitialActions(historyActions);
+
+    // Bookmarks
+    BookmarksMenu *bookmarksMenu = new BookmarksMenu(this);
+    connect(bookmarksMenu, SIGNAL(openUrl(QUrl)),
+            m_tabWidget, SLOT(loadUrlInCurrentTab(QUrl)));
+    connect(bookmarksMenu, SIGNAL(hovered(QString)),
+            this, SLOT(slotUpdateStatusbar(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")));
+#if defined(QWEBENGINEINSPECTOR)
+    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()
+{
+    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(QUrl)), SLOT(loadUrl(QUrl)));
+
+    m_chaseWidget = new ChaseWidget(this);
+    m_navigationBar->addWidget(m_chaseWidget);
+}
+
+void BrowserMainWindow::slotShowBookmarksDialog()
+{
+    BookmarksDialog *dialog = new BookmarksDialog(this);
+    connect(dialog, SIGNAL(openUrl(QUrl)),
+            m_tabWidget, SLOT(loadUrlInCurrentTab(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::handleFindTextResult(bool found)
+{
+    if (!found)
+        slotUpdateStatusbar(tr("\"%1\" not found.").arg(m_lastSearch));
+}
+
+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();
+}
+
+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()
+{
+    // not implemented yet.
+}
+
+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_OS_OSX)
+        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 the facilities "
+        "of Qt WebEngine in action, providing an example "
+        "browser for you to experiment with.<p>"
+        "<p>Qt WebEngine is based on the Chromium open source project "
+        "developed at <a href=\"http://www.chromium.org/\">http://www.chromium.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_PRINTPREVIEWDIALOG
+    if (!currentTab())
+        return;
+    QPrintPreviewDialog *dialog = new QPrintPreviewDialog(this);
+    connect(dialog, SIGNAL(paintRequested(QPrinter*)),
+            currentTab(), SLOT(print(QPrinter*)));
+    dialog->exec();
+#endif
+}
+
+void BrowserMainWindow::slotFilePrint()
+{
+#if defined(QWEBENGINEPAGE_PRINT)
+    if (!currentTab())
+        return;
+    printRequested(currentTab()->page()->mainFrame());
+#endif
+}
+
+#if defined(QWEBENGINEPAGE_PRINT)
+void BrowserMainWindow::printRequested(QWebEngineFrame *frame)
+{
+#ifndef QT_NO_PRINTDIALOG
+    QPrinter printer;
+    QPrintDialog *dialog = new QPrintDialog(&printer, this);
+    dialog->setWindowTitle(tr("Print Document"));
+    if (dialog->exec() != QDialog::Accepted)
+        return;
+    frame->print(&printer);
+#endif
+}
+#endif
+
+void BrowserMainWindow::slotPrivateBrowsing()
+{
+    if (!BrowserApplication::instance()->privateBrowsing()) {
+        QString title = tr("Are you sure you want to turn on private browsing?");
+        QString text = tr("<b>%1</b><br><br>"
+            "This action will reload all open tabs.<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 added 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)
+            BrowserApplication::instance()->setPrivateBrowsing(true);
+    } else {
+        // TODO: Also ask here
+        BrowserApplication::instance()->setPrivateBrowsing(false);
+    }
+}
+
+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 tabs 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;
+        currentTab()->findText(m_lastSearch, 0, invoke(this, &BrowserMainWindow::handleFindTextResult));
+    }
+}
+
+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, QWebEnginePage::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::slotViewFullScreen(bool makeFullScreen)
+{
+    if (makeFullScreen) {
+        showFullScreen();
+    } else {
+        if (isMinimized())
+            showMinimized();
+        else if (isMaximized())
+            showMaximized();
+        else showNormal();
+    }
+}
+
+void BrowserMainWindow::slotViewPageSource()
+{
+    if (!currentTab())
+        return;
+
+    QPlainTextEdit *view = new QPlainTextEdit;
+    view->setWindowTitle(tr("Page Source of %1").arg(currentTab()->title()));
+    view->setMinimumWidth(640);
+    view->setAttribute(Qt::WA_DeleteOnClose);
+    view->show();
+
+    currentTab()->page()->toHtml(invoke(view, &QPlainTextEdit::setPlainText));
+}
+
+void BrowserMainWindow::slotHome()
+{
+    QSettings settings;
+    settings.beginGroup(QLatin1String("MainWindow"));
+    QString home = settings.value(QLatin1String("home"), QLatin1String(defaultHome)).toString();
+    loadPage(home);
+}
+
+void BrowserMainWindow::slotWebSearch()
+{
+    m_toolbarSearch->lineEdit()->selectAll();
+    m_toolbarSearch->lineEdit()->setFocus();
+}
+
+void BrowserMainWindow::slotToggleInspector(bool enable)
+{
+#if defined(QWEBENGINEINSPECTOR)
+    QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::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();
+        }
+    }
+#else
+    Q_UNUSED(enable);
+#endif
+}
+
+void BrowserMainWindow::slotSwapFocus()
+{
+    if (currentTab()->hasFocus())
+        m_tabWidget->currentLineEdit()->setFocus();
+    else
+        currentTab()->setFocus();
+}
+
+void BrowserMainWindow::loadPage(const QString &page)
+{
+    QUrl url = QUrl::fromUserInput(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;
+    QWebEngineHistory *history = currentTab()->history();
+    int historyCount = history->count();
+    for (int i = history->backItems(historyCount).count() - 1; i >= 0; --i) {
+        QWebEngineHistoryItem 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;
+    QWebEngineHistory *history = currentTab()->history();
+    int historyCount = history->count();
+    for (int i = 0; i < history->forwardItems(history->count()).count(); ++i) {
+        QWebEngineHistoryItem 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();
+    QWebEngineHistory *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);
+}