/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the demonstration applications of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "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)

{

    setToolButtonStyle(Qt::ToolButtonFollowStyle);

    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(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_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(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)));

    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(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, 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(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")));

#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(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();