/*

    Copyright (C) 2008, 2009 Nokia Corporation and/or its subsidiary(-ies)

    Copyright (C) 2007 Staikos Computing Services Inc.

    Copyright (C) 2007 Apple Inc.

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Library General Public

    License as published by the Free Software Foundation; either

    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License

    along with this library; see the file COPYING.LIB.  If not, write to

    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    Boston, MA 02110-1301, USA.

*/

#include "config.h"

#include "qwebpage.h"

#include "qwebview.h"

#include "qwebframe.h"

#include "qwebpage_p.h"

#include "qwebframe_p.h"

#include "qwebhistory.h"

#include "qwebhistory_p.h"

#include "qwebinspector.h"

#include "qwebinspector_p.h"

#include "qwebsettings.h"

#include "qwebkitversion.h"

#include "Chrome.h"

#include "ContextMenuController.h"

#include "Frame.h"

#include "FrameTree.h"

#include "FrameLoader.h"

#include "FrameLoaderClientQt.h"

#include "FrameView.h"

#include "FormState.h"

#include "ApplicationCacheStorage.h"

#include "ChromeClientQt.h"

#include "ContextMenu.h"

#include "ContextMenuClientQt.h"

#include "DocumentLoader.h"

#include "DragClientQt.h"

#include "DragController.h"

#include "DragData.h"

#include "EditorClientQt.h"

#include "SchemeRegistry.h"

#include "SecurityOrigin.h"

#include "Settings.h"

#include "Page.h"

#include "Pasteboard.h"

#include "FrameLoader.h"

#include "FrameLoadRequest.h"

#include "KURL.h"

#include "Logging.h"

#include "Image.h"

#include "InspectorClientQt.h"

#include "InspectorController.h"

#include "FocusController.h"

#include "Editor.h"

#include "Scrollbar.h"

#include "PlatformKeyboardEvent.h"

#include "PlatformWheelEvent.h"

#include "PluginDatabase.h"

#include "ProgressTracker.h"

#include "RefPtr.h"

#include "RenderTextControl.h"

#include "TextIterator.h"

#include "HashMap.h"

#include "HTMLFormElement.h"

#include "HTMLInputElement.h"

#include "HTMLNames.h"

#include "HitTestResult.h"

#include "WindowFeatures.h"

#include "LocalizedStrings.h"

#include "Cache.h"

#include "runtime/InitializeThreading.h"

#include "PageGroup.h"

#include "NotificationPresenterClientQt.h"

#include "PageClientQt.h"

#include "WorkerThread.h"

#include "wtf/Threading.h"

#include <QApplication>

#include <QBasicTimer>

#include <QBitArray>

#include <QDebug>

#include <QDragEnterEvent>

#include <QDragLeaveEvent>

#include <QDragMoveEvent>

#include <QDropEvent>

#include <QFileDialog>

#include <QHttpRequestHeader>

#include <QInputDialog>

#include <QLocale>

#include <QMessageBox>

#include <QNetworkProxy>

#include <QUndoStack>

#include <QUrl>

#include <QPainter>

#include <QClipboard>

#include <QSslSocket>

#include <QStyle>

#include <QSysInfo>

#include <QTextCharFormat>

#include <QTextDocument>

#include <QNetworkAccessManager>

#include <QNetworkRequest>

#if defined(Q_WS_X11)

#include <QX11Info>

#endif

#if QT_VERSION >= QT_VERSION_CHECK(4, 6, 0)

#include <QTouchEvent>

#include "PlatformTouchEvent.h"

#endif

using namespace WebCore;

bool QWebPagePrivate::drtRun = false;

// Lookup table mapping QWebPage::WebActions to the associated Editor commands

static const char* editorCommandWebActions[] =

{

    0, // OpenLink,

    0, // OpenLinkInNewWindow,

    0, // OpenFrameInNewWindow,

    0, // DownloadLinkToDisk,

    0, // CopyLinkToClipboard,

    0, // OpenImageInNewWindow,

    0, // DownloadImageToDisk,

    0, // CopyImageToClipboard,

    0, // Back,

    0, // Forward,

    0, // Stop,

    0, // Reload,

    "Cut", // Cut,

    "Copy", // Copy,

    "Paste", // Paste,

    "Undo", // Undo,

    "Redo", // Redo,

    "MoveForward", // MoveToNextChar,

    "MoveBackward", // MoveToPreviousChar,

    "MoveWordForward", // MoveToNextWord,

    "MoveWordBackward", // MoveToPreviousWord,

    "MoveDown", // MoveToNextLine,

    "MoveUp", // MoveToPreviousLine,

    "MoveToBeginningOfLine", // MoveToStartOfLine,

    "MoveToEndOfLine", // MoveToEndOfLine,

    "MoveToBeginningOfParagraph", // MoveToStartOfBlock,

    "MoveToEndOfParagraph", // MoveToEndOfBlock,

    "MoveToBeginningOfDocument", // MoveToStartOfDocument,

    "MoveToEndOfDocument", // MoveToEndOfDocument,

    "MoveForwardAndModifySelection", // SelectNextChar,

    "MoveBackwardAndModifySelection", // SelectPreviousChar,

    "MoveWordForwardAndModifySelection", // SelectNextWord,

    "MoveWordBackwardAndModifySelection", // SelectPreviousWord,

    "MoveDownAndModifySelection", // SelectNextLine,

    "MoveUpAndModifySelection", // SelectPreviousLine,

    "MoveToBeginningOfLineAndModifySelection", // SelectStartOfLine,

    "MoveToEndOfLineAndModifySelection", // SelectEndOfLine,

    "MoveToBeginningOfParagraphAndModifySelection", // SelectStartOfBlock,

    "MoveToEndOfParagraphAndModifySelection", // SelectEndOfBlock,

    "MoveToBeginningOfDocumentAndModifySelection", //SelectStartOfDocument,

    "MoveToEndOfDocumentAndModifySelection", // SelectEndOfDocument,

    "DeleteWordBackward", // DeleteStartOfWord,

    "DeleteWordForward", // DeleteEndOfWord,

    0, // SetTextDirectionDefault,

    0, // SetTextDirectionLeftToRight,

    0, // SetTextDirectionRightToLeft,

    "ToggleBold", // ToggleBold,

    "ToggleItalic", // ToggleItalic,

    "ToggleUnderline", // ToggleUnderline,

    0, // InspectElement,

    "InsertNewline", // InsertParagraphSeparator

    "InsertLineBreak", // InsertLineSeparator

    "SelectAll", // SelectAll

    0, // ReloadAndBypassCache,

    "PasteAndMatchStyle", // PasteAndMatchStyle

    "RemoveFormat", // RemoveFormat

    "Strikethrough", // ToggleStrikethrough,

    "Subscript", // ToggleSubscript

    "Superscript", // ToggleSuperscript

    "InsertUnorderedList", // InsertUnorderedList

    "InsertOrderedList", // InsertOrderedList

    "Indent", // Indent

    "Outdent", // Outdent,

    "AlignCenter", // AlignCenter,

    "AlignJustified", // AlignJustified,

    "AlignLeft", // AlignLeft,

    "AlignRight", // AlignRight,

    0 // WebActionCount

};

// Lookup the appropriate editor command to use for WebAction \a action

const char* QWebPagePrivate::editorCommandForWebActions(QWebPage::WebAction action)

{

    if ((action > QWebPage::NoWebAction) && (action < int(sizeof(editorCommandWebActions) / sizeof(const char*))))

        return editorCommandWebActions[action];

    return 0;

}

static inline DragOperation dropActionToDragOp(Qt::DropActions actions)

{

    unsigned result = 0;

    if (actions & Qt::CopyAction)

        result |= DragOperationCopy;

    // DragOperationgeneric represents InternetExplorer's equivalent of Move operation,

    // hence it should be considered as "move"

    if (actions & Qt::MoveAction)

        result |= (DragOperationMove | DragOperationGeneric);

    if (actions & Qt::LinkAction)

        result |= DragOperationLink;

    return (DragOperation)result;

}

static inline Qt::DropAction dragOpToDropAction(unsigned actions)

{

    Qt::DropAction result = Qt::IgnoreAction;

    if (actions & DragOperationCopy)

        result = Qt::CopyAction;

    else if (actions & DragOperationMove)

        result = Qt::MoveAction;

    // DragOperationgeneric represents InternetExplorer's equivalent of Move operation,

    // hence it should be considered as "move"

    else if (actions & DragOperationGeneric)

        result = Qt::MoveAction;

    else if (actions & DragOperationLink)

        result = Qt::LinkAction;

    return result;

}

QWebPagePrivate::QWebPagePrivate(QWebPage *qq)

    : q(qq)

    , client(0)

#if QT_VERSION < 0x040600

    , view(0)

#endif

    , clickCausedFocus(false)

    , viewportSize(QSize(0, 0))

    , inspectorFrontend(0)

    , inspector(0)

    , inspectorIsInternalOnly(false)

{

    WebCore::InitializeLoggingChannelsIfNecessary();

    JSC::initializeThreading();

    WTF::initializeMainThread();

    WebCore::SecurityOrigin::setLocalLoadPolicy(WebCore::SecurityOrigin::AllowLocalLoadsForLocalAndSubstituteData);

#if QT_VERSION < QT_VERSION_CHECK(4, 7, 0)

    WebCore::Font::setCodePath(WebCore::Font::Complex);

#endif

    chromeClient = new ChromeClientQt(q);

    contextMenuClient = new ContextMenuClientQt();

    editorClient = new EditorClientQt(q);

    page = new Page(chromeClient, contextMenuClient, editorClient,

                    new DragClientQt(q), new InspectorClientQt(q), 0, 0, 0, 0);

    settings = new QWebSettings(page->settings());

#ifndef QT_NO_UNDOSTACK

    undoStack = 0;

#endif

    mainFrame = 0;

    networkManager = 0;

    pluginFactory = 0;

    insideOpenCall = false;

    forwardUnsupportedContent = false;

    editable = false;

    useFixedLayout = false;

    linkPolicy = QWebPage::DontDelegateLinks;

#ifndef QT_NO_CONTEXTMENU

    currentContextMenu = 0;

#endif

    smartInsertDeleteEnabled = true;

    selectTrailingWhitespaceEnabled = false;

    history.d = new QWebHistoryPrivate(page->backForwardList());

    memset(actions, 0, sizeof(actions));

    PageGroup::setShouldTrackVisitedLinks(true);

#if ENABLE(NOTIFICATIONS)    

    NotificationPresenterClientQt::notificationPresenter()->addClient();

#endif

}

QWebPagePrivate::~QWebPagePrivate()

{

#ifndef QT_NO_CONTEXTMENU

    delete currentContextMenu;

#endif

#ifndef QT_NO_UNDOSTACK

    delete undoStack;

#endif

    delete settings;

    delete page;

#if ENABLE(NOTIFICATIONS)

    NotificationPresenterClientQt::notificationPresenter()->removeClient();

#endif

}

WebCore::Page* QWebPagePrivate::core(QWebPage* page)

{

    return page->d->page;

}

QWebPagePrivate* QWebPagePrivate::priv(QWebPage* page)

{

    return page->d;

}

bool QWebPagePrivate::acceptNavigationRequest(QWebFrame *frame, const QNetworkRequest &request, QWebPage::NavigationType type)

{

    if (insideOpenCall

        && frame == mainFrame)

        return true;

    return q->acceptNavigationRequest(frame, request, type);

}

void QWebPagePrivate::createMainFrame()

{

    if (!mainFrame) {

        QWebFrameData frameData(page);

        mainFrame = new QWebFrame(q, &frameData);

        emit q->frameCreated(mainFrame);

    }

}

static QWebPage::WebAction webActionForContextMenuAction(WebCore::ContextMenuAction action)

{

    switch (action) {

        case WebCore::ContextMenuItemTagOpenLink: return QWebPage::OpenLink;

        case WebCore::ContextMenuItemTagOpenLinkInNewWindow: return QWebPage::OpenLinkInNewWindow;

        case WebCore::ContextMenuItemTagDownloadLinkToDisk: return QWebPage::DownloadLinkToDisk;

        case WebCore::ContextMenuItemTagCopyLinkToClipboard: return QWebPage::CopyLinkToClipboard;

        case WebCore::ContextMenuItemTagOpenImageInNewWindow: return QWebPage::OpenImageInNewWindow;

        case WebCore::ContextMenuItemTagDownloadImageToDisk: return QWebPage::DownloadImageToDisk;

        case WebCore::ContextMenuItemTagCopyImageToClipboard: return QWebPage::CopyImageToClipboard;

        case WebCore::ContextMenuItemTagOpenFrameInNewWindow: return QWebPage::OpenFrameInNewWindow;

        case WebCore::ContextMenuItemTagCopy: return QWebPage::Copy;

        case WebCore::ContextMenuItemTagGoBack: return QWebPage::Back;

        case WebCore::ContextMenuItemTagGoForward: return QWebPage::Forward;

        case WebCore::ContextMenuItemTagStop: return QWebPage::Stop;

        case WebCore::ContextMenuItemTagReload: return QWebPage::Reload;

        case WebCore::ContextMenuItemTagCut: return QWebPage::Cut;

        case WebCore::ContextMenuItemTagPaste: return QWebPage::Paste;

        case WebCore::ContextMenuItemTagDefaultDirection: return QWebPage::SetTextDirectionDefault;

        case WebCore::ContextMenuItemTagLeftToRight: return QWebPage::SetTextDirectionLeftToRight;

        case WebCore::ContextMenuItemTagRightToLeft: return QWebPage::SetTextDirectionRightToLeft;

        case WebCore::ContextMenuItemTagBold: return QWebPage::ToggleBold;

        case WebCore::ContextMenuItemTagItalic: return QWebPage::ToggleItalic;

        case WebCore::ContextMenuItemTagUnderline: return QWebPage::ToggleUnderline;

#if ENABLE(INSPECTOR)

        case WebCore::ContextMenuItemTagInspectElement: return QWebPage::InspectElement;

#endif

        default: break;

    }

    return QWebPage::NoWebAction;

}

#ifndef QT_NO_CONTEXTMENU

QMenu *QWebPagePrivate::createContextMenu(const WebCore::ContextMenu *webcoreMenu,

        const QList<WebCore::ContextMenuItem> *items, QBitArray *visitedWebActions)

{

    if (!client)

        return 0;

    QMenu* menu = new QMenu(client->ownerWidget());

    for (int i = 0; i < items->count(); ++i) {

        const ContextMenuItem &item = items->at(i);

        switch (item.type()) {

            case WebCore::CheckableActionType: /* fall through */

            case WebCore::ActionType: {

                QWebPage::WebAction action = webActionForContextMenuAction(item.action());

                QAction *a = q->action(action);

                if (a) {

                    ContextMenuItem it(item);

                    webcoreMenu->checkOrEnableIfNeeded(it);

                    PlatformMenuItemDescription desc = it.releasePlatformDescription();

                    a->setEnabled(desc.enabled);

                    a->setChecked(desc.checked);

                    a->setCheckable(item.type() == WebCore::CheckableActionType);

                    menu->addAction(a);

                    visitedWebActions->setBit(action);

                }

                break;

            }

            case WebCore::SeparatorType:

                menu->addSeparator();

                break;

            case WebCore::SubmenuType: {

                QMenu *subMenu = createContextMenu(webcoreMenu, item.platformSubMenu(), visitedWebActions);

                bool anyEnabledAction = false;

                QList<QAction *> actions = subMenu->actions();

                for (int i = 0; i < actions.count(); ++i) {

                    if (actions.at(i)->isVisible())

                        anyEnabledAction |= actions.at(i)->isEnabled();

                }

                // don't show sub-menus with just disabled actions

                if (anyEnabledAction) {

                    subMenu->setTitle(item.title());

                    menu->addAction(subMenu->menuAction());

                } else

                    delete subMenu;

                break;

            }

        }

    }

    return menu;

}

#endif // QT_NO_CONTEXTMENU

#ifndef QT_NO_ACTION

void QWebPagePrivate::_q_webActionTriggered(bool checked)

{

    QAction *a = qobject_cast<QAction *>(q->sender());

    if (!a)

        return;

    QWebPage::WebAction action = static_cast<QWebPage::WebAction>(a->data().toInt());

    q->triggerAction(action, checked);

}

#endif // QT_NO_ACTION

void QWebPagePrivate::_q_cleanupLeakMessages()

{

#ifndef NDEBUG

    // Need this to make leak messages accurate.

    cache()->setCapacities(0, 0, 0);

#endif

}

void QWebPagePrivate::updateAction(QWebPage::WebAction action)

{

#ifdef QT_NO_ACTION

    Q_UNUSED(action)

#else

    QAction *a = actions[action];

    if (!a || !mainFrame)

        return;

    WebCore::FrameLoader *loader = mainFrame->d->frame->loader();

    WebCore::Editor *editor = page->focusController()->focusedOrMainFrame()->editor();

    bool enabled = a->isEnabled();

    bool checked = a->isChecked();

    switch (action) {

        case QWebPage::Back:

            enabled = page->canGoBackOrForward(-1);

            break;

        case QWebPage::Forward:

            enabled = page->canGoBackOrForward(1);

            break;

        case QWebPage::Stop:

            enabled = loader->isLoading();

            break;

        case QWebPage::Reload:

        case QWebPage::ReloadAndBypassCache:

            enabled = !loader->isLoading();

            break;

#ifndef QT_NO_UNDOSTACK

        case QWebPage::Undo:

        case QWebPage::Redo:

            // those two are handled by QUndoStack

            break;

#endif // QT_NO_UNDOSTACK

        case QWebPage::SelectAll: // editor command is always enabled

            break;

        case QWebPage::SetTextDirectionDefault:

        case QWebPage::SetTextDirectionLeftToRight:

        case QWebPage::SetTextDirectionRightToLeft:

            enabled = editor->canEdit();

            checked = false;

            break;

        default: {

            // see if it's an editor command

            const char* commandName = editorCommandForWebActions(action);

            // if it's an editor command, let it's logic determine state

            if (commandName) {

                Editor::Command command = editor->command(commandName);

                enabled = command.isEnabled();

                if (enabled)

                    checked = command.state() != FalseTriState;

                else

                    checked = false;

            }

            break;

        }

    }

    a->setEnabled(enabled);

    if (a->isCheckable())

        a->setChecked(checked);

#endif // QT_NO_ACTION

}

void QWebPagePrivate::updateNavigationActions()

{

    updateAction(QWebPage::Back);