/*

 * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)

 * Copyright (C) 2009 Girish Ramakrishnan <girish@forwardbias.in>

 * Copyright (C) 2006 George Staikos <staikos@kde.org>

 * Copyright (C) 2006 Dirk Mueller <mueller@kde.org>

 * Copyright (C) 2006 Zack Rusin <zack@kde.org>

 * Copyright (C) 2006 Simon Hausmann <hausmann@kde.org>

 *

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "launcherwindow.h"

const int gExitClickArea = 80;

QVector<int> LauncherWindow::m_zoomLevels;

LauncherWindow::LauncherWindow(WindowOptions* data, QGraphicsScene* sharedScene)

    : MainWindow()

    , m_currentZoom(100)

    , m_view(0)

    , m_inspector(0)

    , m_formatMenuAction(0)

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

    , m_zoomAnimation(0)

#endif

{

    if (data)

        m_windowOptions = *data;

    init();

    if (sharedScene && data->useGraphicsView)

        static_cast<QGraphicsView*>(m_view)->setScene(sharedScene);

    createChrome();

}

LauncherWindow::~LauncherWindow()

{

    grabZoomKeys(false);

}

void LauncherWindow::init()

{

    QSplitter* splitter = new QSplitter(Qt::Vertical, this);

    setCentralWidget(splitter);

#if defined(Q_WS_S60)

    setWindowState(Qt::WindowMaximized);

#else

    setWindowState(Qt::WindowNoState);

    resize(800, 600);

#endif

    initializeView();

    connect(page(), SIGNAL(loadStarted()), this, SLOT(loadStarted()));

    connect(page(), SIGNAL(loadFinished(bool)), this, SLOT(loadFinished()));

    connect(page(), SIGNAL(linkHovered(const QString&, const QString&, const QString&)),

            this, SLOT(showLinkHover(const QString&, const QString&)));

    connect(this, SIGNAL(enteredFullScreenMode(bool)), this, SLOT(toggleFullScreenMode(bool)));

    applyPrefs();

    m_inspector = new WebInspector(splitter);

#ifndef QT_NO_PROPERTIES

    if (!m_windowOptions.inspectorUrl.isEmpty())

        m_inspector->setProperty("_q_inspectorUrl", m_windowOptions.inspectorUrl);

#endif

    m_inspector->setPage(page());

    m_inspector->hide();

    connect(this, SIGNAL(destroyed()), m_inspector, SLOT(deleteLater()));

    // the zoom values are chosen to be like in Mozilla Firefox 3

    if (!m_zoomLevels.count()) {

        m_zoomLevels << 30 << 50 << 67 << 80 << 90;

        m_zoomLevels << 100;

        m_zoomLevels << 110 << 120 << 133 << 150 << 170 << 200 << 240 << 300;

    }

    grabZoomKeys(true);

}

void LauncherWindow::initializeView()

{

    delete m_view;

    QSplitter* splitter = static_cast<QSplitter*>(centralWidget());

    if (!m_windowOptions.useGraphicsView) {

        WebViewTraditional* view = new WebViewTraditional(splitter);

        view->setPage(page());

        view->installEventFilter(this);

        m_view = view;

    } else {

        WebViewGraphicsBased* view = new WebViewGraphicsBased(splitter);

        view->setPage(page());

        connect(view, SIGNAL(currentFPSUpdated(int)), this, SLOT(updateFPS(int)));

        view->installEventFilter(this);

        // The implementation of QAbstractScrollArea::eventFilter makes us need

        // to install the event filter also on the viewport of a QGraphicsView.

        view->viewport()->installEventFilter(this);

        m_view = view;

    }

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

    m_touchMocking = false;

#endif

}

void LauncherWindow::applyPrefs()

{

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

    settings->setAttribute(QWebSettings::AcceleratedCompositingEnabled, m_windowOptions.useCompositing);

    settings->setAttribute(QWebSettings::TiledBackingStoreEnabled, m_windowOptions.useTiledBackingStore);

    settings->setAttribute(QWebSettings::FrameFlatteningEnabled, m_windowOptions.useFrameFlattening);

    settings->setAttribute(QWebSettings::WebGLEnabled, m_windowOptions.useWebGL);

    if (!isGraphicsBased())

        return;

    WebViewGraphicsBased* view = static_cast<WebViewGraphicsBased*>(m_view);

    view->setViewportUpdateMode(m_windowOptions.viewportUpdateMode);

    view->setFrameRateMeasurementEnabled(m_windowOptions.showFrameRate);

    view->setItemCacheMode(m_windowOptions.cacheWebView ? QGraphicsItem::DeviceCoordinateCache : QGraphicsItem::NoCache);

    if (m_windowOptions.resizesToContents)

        toggleResizesToContents(m_windowOptions.resizesToContents);

}

void LauncherWindow::createChrome()

{

    QMenu* fileMenu = menuBar()->addMenu("&File");

    fileMenu->addAction("New Window", this, SLOT(newWindow()), QKeySequence::New);

    fileMenu->addAction(tr("Open File..."), this, SLOT(openFile()), QKeySequence::Open);

    fileMenu->addAction(tr("Open Location..."), this, SLOT(openLocation()), QKeySequence(Qt::CTRL | Qt::Key_L));

    fileMenu->addAction("Close Window", this, SLOT(close()), QKeySequence::Close);

    fileMenu->addSeparator();

    fileMenu->addAction("Take Screen Shot...", this, SLOT(screenshot()));

    fileMenu->addAction(tr("Print..."), this, SLOT(print()), QKeySequence::Print);

    fileMenu->addSeparator();

    fileMenu->addAction("Quit", QApplication::instance(), SLOT(closeAllWindows()), QKeySequence(Qt::CTRL | Qt::Key_Q));

    QMenu* editMenu = menuBar()->addMenu("&Edit");

    editMenu->addAction(page()->action(QWebPage::Undo));

    editMenu->addAction(page()->action(QWebPage::Redo));

    editMenu->addSeparator();

    editMenu->addAction(page()->action(QWebPage::Cut));

    editMenu->addAction(page()->action(QWebPage::Copy));

    editMenu->addAction(page()->action(QWebPage::Paste));

    editMenu->addSeparator();

    QAction* setEditable = editMenu->addAction("Set Editable", this, SLOT(setEditable(bool)));

    setEditable->setCheckable(true);

    QMenu* viewMenu = menuBar()->addMenu("&View");

    viewMenu->addAction(page()->action(QWebPage::Stop));

    viewMenu->addAction(page()->action(QWebPage::Reload));

    viewMenu->addSeparator();

    QAction* zoomIn = viewMenu->addAction("Zoom &In", this, SLOT(zoomIn()));

    QAction* zoomOut = viewMenu->addAction("Zoom &Out", this, SLOT(zoomOut()));

    QAction* resetZoom = viewMenu->addAction("Reset Zoom", this, SLOT(resetZoom()));

    QAction* zoomTextOnly = viewMenu->addAction("Zoom Text Only", this, SLOT(toggleZoomTextOnly(bool)));

    zoomTextOnly->setCheckable(true);

    zoomTextOnly->setChecked(false);

    viewMenu->addSeparator();

    viewMenu->addAction("Dump HTML", this, SLOT(dumpHtml()));

    // viewMenu->addAction("Dump plugins", this, SLOT(dumpPlugins()));

    zoomIn->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_Plus));

    zoomOut->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_Minus));

    resetZoom->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_0));

    QMenu* formatMenu = new QMenu("F&ormat", this);

    m_formatMenuAction = menuBar()->addMenu(formatMenu);

    m_formatMenuAction->setVisible(false);

    formatMenu->addAction(page()->action(QWebPage::ToggleBold));

    formatMenu->addAction(page()->action(QWebPage::ToggleItalic));

    formatMenu->addAction(page()->action(QWebPage::ToggleUnderline));

    QMenu* writingMenu = formatMenu->addMenu(tr("Writing Direction"));

    writingMenu->addAction(page()->action(QWebPage::SetTextDirectionDefault));

    writingMenu->addAction(page()->action(QWebPage::SetTextDirectionLeftToRight));

    writingMenu->addAction(page()->action(QWebPage::SetTextDirectionRightToLeft));

    QMenu* windowMenu = menuBar()->addMenu("&Window");

    QAction* toggleFullScreen = windowMenu->addAction("Toggle FullScreen", this, SIGNAL(enteredFullScreenMode(bool)));

    toggleFullScreen->setCheckable(true);

    toggleFullScreen->setChecked(false);

    // When exit fullscreen mode by clicking on the exit area (bottom right corner) we must

    // uncheck the Toggle FullScreen action.

    toggleFullScreen->connect(this, SIGNAL(enteredFullScreenMode(bool)), SLOT(setChecked(bool)));

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

    QMenu* toolsMenu = menuBar()->addMenu("&Develop");

    QMenu* graphicsViewMenu = toolsMenu->addMenu("QGraphicsView");

    QAction* toggleGraphicsView = graphicsViewMenu->addAction("Toggle use of QGraphicsView", this, SLOT(initializeView()));

    toggleGraphicsView->setCheckable(true);

    toggleGraphicsView->setChecked(isGraphicsBased());

    QAction* toggleWebGL = toolsMenu->addAction("Toggle WebGL", this, SLOT(toggleWebGL(bool)));

    toggleWebGL->setCheckable(true);

    toggleWebGL->setChecked(settings->testAttribute(QWebSettings::WebGLEnabled));

    QAction* spatialNavigationAction = toolsMenu->addAction("Toggle Spatial Navigation", this, SLOT(toggleSpatialNavigation(bool)));

    spatialNavigationAction->setCheckable(true);

    spatialNavigationAction->setShortcut(QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_S));

    QAction* toggleFrameFlattening = toolsMenu->addAction("Toggle Frame Flattening", this, SLOT(toggleFrameFlattening(bool)));

    toggleFrameFlattening->setCheckable(true);

    toggleFrameFlattening->setChecked(settings->testAttribute(QWebSettings::FrameFlatteningEnabled));

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

    QAction* touchMockAction = toolsMenu->addAction("Toggle multitouch mocking", this, SLOT(setTouchMocking(bool)));

    touchMockAction->setCheckable(true);

    touchMockAction->setShortcut(QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_T));

#endif

    toolsMenu->addSeparator();

    QAction* toggleInterruptingJavaScripteEnabled = toolsMenu->addAction("Enable interrupting js scripts", this, SLOT(toggleInterruptingJavaScriptEnabled(bool)));

    toggleInterruptingJavaScripteEnabled->setCheckable(true);

    toggleInterruptingJavaScripteEnabled->setChecked(false);

    QAction* toggleJavascriptCanOpenWindows = toolsMenu->addAction("Enable js popup windows", this, SLOT(toggleJavascriptCanOpenWindows(bool)));

    toggleJavascriptCanOpenWindows->setCheckable(true);

    toggleJavascriptCanOpenWindows->setChecked(false);

    toolsMenu->addSeparator();

    QAction* userAgentAction = toolsMenu->addAction("Change User Agent", this, SLOT(showUserAgentDialog()));

    userAgentAction->setShortcut(QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_U));

    toolsMenu->addAction("Select Elements...", this, SLOT(selectElements()));

    QAction* showInspectorAction = toolsMenu->addAction("Show Web Inspector", m_inspector, SLOT(setVisible(bool)), QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_I));

    showInspectorAction->setCheckable(true);

    showInspectorAction->connect(m_inspector, SIGNAL(visibleChanged(bool)), SLOT(setChecked(bool)));

    // GraphicsView sub menu.

    QAction* toggleAcceleratedCompositing = graphicsViewMenu->addAction("Toggle Accelerated Compositing", this, SLOT(toggleAcceleratedCompositing(bool)));

    toggleAcceleratedCompositing->setCheckable(true);

    toggleAcceleratedCompositing->setChecked(settings->testAttribute(QWebSettings::AcceleratedCompositingEnabled));

    toggleAcceleratedCompositing->setEnabled(isGraphicsBased());

    toggleAcceleratedCompositing->connect(toggleGraphicsView, SIGNAL(toggled(bool)), SLOT(setEnabled(bool)));

    QAction* toggleResizesToContents = graphicsViewMenu->addAction("Toggle Resizes To Contents Mode", this, SLOT(toggleResizesToContents(bool)));

    toggleResizesToContents->setCheckable(true);

    toggleResizesToContents->setChecked(m_windowOptions.resizesToContents);

    toggleResizesToContents->setEnabled(isGraphicsBased());

    toggleResizesToContents->connect(toggleGraphicsView, SIGNAL(toggled(bool)), SLOT(setEnabled(bool)));

    QAction* toggleTiledBackingStore = graphicsViewMenu->addAction("Toggle Tiled Backing Store", this, SLOT(toggleTiledBackingStore(bool)));

    toggleTiledBackingStore->setCheckable(true);

    toggleResizesToContents->setChecked(m_windowOptions.useTiledBackingStore);

    toggleTiledBackingStore->setEnabled(isGraphicsBased());

    toggleTiledBackingStore->connect(toggleGraphicsView, SIGNAL(toggled(bool)), SLOT(setEnabled(bool)));

#if defined(QT_CONFIGURED_WITH_OPENGL)

    QAction* toggleQGLWidgetViewport = graphicsViewMenu->addAction("Toggle use of QGLWidget Viewport", this, SLOT(toggleQGLWidgetViewport(bool)));

    toggleQGLWidgetViewport->setCheckable(true);

    toggleQGLWidgetViewport->setChecked(m_windowOptions.useQGLWidgetViewport);

    toggleQGLWidgetViewport->setEnabled(isGraphicsBased());

    toggleQGLWidgetViewport->connect(toggleGraphicsView, SIGNAL(toggled(bool)), SLOT(setEnabled(bool)));

#endif

    QMenu* viewportUpdateMenu = graphicsViewMenu->addMenu("Change Viewport Update Mode");

    viewportUpdateMenu->setEnabled(isGraphicsBased());

    viewportUpdateMenu->connect(toggleGraphicsView, SIGNAL(toggled(bool)), SLOT(setEnabled(bool)));

    QAction* fullUpdate = viewportUpdateMenu->addAction("FullViewportUpdate");

    fullUpdate->setCheckable(true);

    fullUpdate->setChecked((m_windowOptions.viewportUpdateMode == QGraphicsView::FullViewportUpdate) ? true : false);

    QAction* minimalUpdate = viewportUpdateMenu->addAction("MinimalViewportUpdate");

    minimalUpdate->setCheckable(true);

    minimalUpdate->setChecked((m_windowOptions.viewportUpdateMode == QGraphicsView::MinimalViewportUpdate) ? true : false);

    QAction* smartUpdate = viewportUpdateMenu->addAction("SmartViewportUpdate");

    smartUpdate->setCheckable(true);

    smartUpdate->setChecked((m_windowOptions.viewportUpdateMode == QGraphicsView::SmartViewportUpdate) ? true : false);

    QAction* boundingRectUpdate = viewportUpdateMenu->addAction("BoundingRectViewportUpdate");

    boundingRectUpdate->setCheckable(true);

    boundingRectUpdate->setChecked((m_windowOptions.viewportUpdateMode == QGraphicsView::BoundingRectViewportUpdate) ? true : false);

    QAction* noUpdate = viewportUpdateMenu->addAction("NoViewportUpdate");

    noUpdate->setCheckable(true);

    noUpdate->setChecked((m_windowOptions.viewportUpdateMode == QGraphicsView::NoViewportUpdate) ? true : false);

    QSignalMapper* signalMapper = new QSignalMapper(viewportUpdateMenu);

    signalMapper->setMapping(fullUpdate, QGraphicsView::FullViewportUpdate);

    signalMapper->setMapping(minimalUpdate, QGraphicsView::MinimalViewportUpdate);

    signalMapper->setMapping(smartUpdate, QGraphicsView::SmartViewportUpdate);

    signalMapper->setMapping(boundingRectUpdate, QGraphicsView::BoundingRectViewportUpdate);

    signalMapper->setMapping(noUpdate, QGraphicsView::NoViewportUpdate);

    connect(fullUpdate, SIGNAL(triggered()), signalMapper, SLOT(map()));

    connect(minimalUpdate, SIGNAL(triggered()), signalMapper, SLOT(map()));

    connect(smartUpdate, SIGNAL(triggered()), signalMapper, SLOT(map()));

    connect(boundingRectUpdate, SIGNAL(triggered()), signalMapper, SLOT(map()));

    connect(noUpdate, SIGNAL(triggered()), signalMapper, SLOT(map()));

    connect(signalMapper, SIGNAL(mapped(int)), this, SLOT(changeViewportUpdateMode(int)));

    QActionGroup* viewportUpdateModeActions = new QActionGroup(viewportUpdateMenu);

    viewportUpdateModeActions->addAction(fullUpdate);

    viewportUpdateModeActions->addAction(minimalUpdate);

    viewportUpdateModeActions->addAction(smartUpdate);

    viewportUpdateModeActions->addAction(boundingRectUpdate);

    viewportUpdateModeActions->addAction(noUpdate);

    graphicsViewMenu->addSeparator();

    QAction* flipAnimated = graphicsViewMenu->addAction("Animated Flip");

    flipAnimated->connect(toggleGraphicsView, SIGNAL(toggled(bool)), SLOT(setEnabled(bool)));

    flipAnimated->setEnabled(isGraphicsBased());

    QAction* flipYAnimated = graphicsViewMenu->addAction("Animated Y-Flip");

    flipYAnimated->connect(toggleGraphicsView, SIGNAL(toggled(bool)), SLOT(setEnabled(bool)));

    flipYAnimated->setEnabled(isGraphicsBased());

    if (isGraphicsBased()) {

        WebViewGraphicsBased* view = static_cast<WebViewGraphicsBased*>(m_view);

        connect(flipAnimated, SIGNAL(triggered()), view, SLOT(animatedFlip()));

        connect(flipYAnimated, SIGNAL(triggered()), view, SLOT(animatedYFlip()));

    }

    QAction* cloneWindow = graphicsViewMenu->addAction("Clone Window", this, SLOT(cloneWindow()));

    cloneWindow->connect(toggleGraphicsView, SIGNAL(toggled(bool)), SLOT(setEnabled(bool)));

    cloneWindow->setEnabled(isGraphicsBased());

    graphicsViewMenu->addSeparator();

    QAction* showFPS = graphicsViewMenu->addAction("Show FPS", this, SLOT(showFPS(bool)));

    showFPS->setCheckable(true);

    showFPS->setEnabled(isGraphicsBased());

    showFPS->connect(toggleGraphicsView, SIGNAL(toggled(bool)), SLOT(setEnabled(bool)));

    showFPS->setChecked(m_windowOptions.showFrameRate);

}

bool LauncherWindow::isGraphicsBased() const

{

    return bool(qobject_cast<QGraphicsView*>(m_view));

}

void LauncherWindow::keyPressEvent(QKeyEvent* event)

{

#ifdef Q_WS_MAEMO_5

    switch (event->key()) {

    case Qt::Key_F7:

        zoomIn();

        event->accept();

        break;

    case Qt::Key_F8:

        zoomOut();

        event->accept();

        break;

    }

#endif

    MainWindow::keyPressEvent(event);

}

void LauncherWindow::grabZoomKeys(bool grab)

{

#ifdef Q_WS_MAEMO_5

    if (!winId()) {

        qWarning("Can't grab keys unless we have a window id");

        return;

    }

    Atom atom = XInternAtom(QX11Info::display(), "_HILDON_ZOOM_KEY_ATOM", False);

    if (!atom) {

        qWarning("Unable to obtain _HILDON_ZOOM_KEY_ATOM");

        return;

    }

    unsigned long val = (grab) ? 1 : 0;

    XChangeProperty(QX11Info::display(), winId(), atom, XA_INTEGER, 32, PropModeReplace, reinterpret_cast<unsigned char*>(&val), 1);

#endif

}

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

void LauncherWindow::sendTouchEvent()

{

    if (m_touchPoints.isEmpty())

        return;

    QEvent::Type type = QEvent::TouchUpdate;

    if (m_touchPoints.size() == 1) {

        if (m_touchPoints[0].state() == Qt::TouchPointReleased)

            type = QEvent::TouchEnd;

        else if (m_touchPoints[0].state() == Qt::TouchPointPressed)

            type = QEvent::TouchBegin;

    }

    QTouchEvent touchEv(type);

    touchEv.setTouchPoints(m_touchPoints);

    QCoreApplication::sendEvent(page(), &touchEv);

    // After sending the event, remove all touchpoints that were released

    if (m_touchPoints[0].state() == Qt::TouchPointReleased)

        m_touchPoints.removeAt(0);

    if (m_touchPoints.size() > 1 && m_touchPoints[1].state() == Qt::TouchPointReleased)

        m_touchPoints.removeAt(1);

}

#endif // QT_VERSION >= QT_VERSION_CHECK(4, 6, 0)

bool LauncherWindow::eventFilter(QObject* obj, QEvent* event)

{

    // If click pos is the bottom right corner (square with size defined by gExitClickArea)

    // and the window is on FullScreen, the window must return to its original state.

    if (event->type() == QEvent::MouseButtonRelease) {

        QMouseEvent* ev = static_cast<QMouseEvent*>(event);

        if (windowState() == Qt::WindowFullScreen

            && ev->pos().x() > (width() - gExitClickArea)

            && ev->pos().y() > (height() - gExitClickArea)) {

            emit enteredFullScreenMode(false);

        }

    }

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

    if (!m_touchMocking)

        return QObject::eventFilter(obj, event);

    if (event->type() == QEvent::MouseButtonPress

        || event->type() == QEvent::MouseButtonRelease

        || event->type() == QEvent::MouseButtonDblClick

        || event->type() == QEvent::MouseMove) {

        QMouseEvent* ev = static_cast<QMouseEvent*>(event);

        if (ev->type() == QEvent::MouseMove

            && !(ev->buttons() & Qt::LeftButton))

            return false;

        QTouchEvent::TouchPoint touchPoint;

        touchPoint.setState(Qt::TouchPointMoved);

        if ((ev->type() == QEvent::MouseButtonPress

             || ev->type() == QEvent::MouseButtonDblClick))

            touchPoint.setState(Qt::TouchPointPressed);

        else if (ev->type() == QEvent::MouseButtonRelease)

            touchPoint.setState(Qt::TouchPointReleased);

        touchPoint.setId(0);

        touchPoint.setScreenPos(ev->globalPos());

        touchPoint.setPos(ev->pos());

        touchPoint.setPressure(1);

        // If the point already exists, update it. Otherwise create it.

        if (m_touchPoints.size() > 0 && !m_touchPoints[0].id())

            m_touchPoints[0] = touchPoint;

        else if (m_touchPoints.size() > 1 && !m_touchPoints[1].id())

            m_touchPoints[1] = touchPoint;

        else

            m_touchPoints.append(touchPoint);

        sendTouchEvent();

    } else if (event->type() == QEvent::KeyPress

        && static_cast<QKeyEvent*>(event)->key() == Qt::Key_F

        && static_cast<QKeyEvent*>(event)->modifiers() == Qt::ControlModifier) {

        // If the keyboard point is already pressed, release it.

        // Otherwise create it and append to m_touchPoints.

        if (m_touchPoints.size() > 0 && m_touchPoints[0].id() == 1) {

            m_touchPoints[0].setState(Qt::TouchPointReleased);

            sendTouchEvent();

        } else if (m_touchPoints.size() > 1 && m_touchPoints[1].id() == 1) {

            m_touchPoints[1].setState(Qt::TouchPointReleased);

            sendTouchEvent();

        } else {

            QTouchEvent::TouchPoint touchPoint;

            touchPoint.setState(Qt::TouchPointPressed);

            touchPoint.setId(1);

            touchPoint.setScreenPos(QCursor::pos());

            touchPoint.setPos(m_view->mapFromGlobal(QCursor::pos()));

            touchPoint.setPressure(1);

            m_touchPoints.append(touchPoint);

            sendTouchEvent();

            // After sending the event, change the touchpoint state to stationary

            m_touchPoints.last().setState(Qt::TouchPointStationary);

        }

    }

#endif // QT_VERSION >= QT_VERSION_CHECK(4, 6, 0)

    return false;

}

void LauncherWindow::loadStarted()

{

    m_view->setFocus(Qt::OtherFocusReason);

}

void LauncherWindow::loadFinished()

{

    QUrl url = page()->mainFrame()->url();

    setAddressUrl(url.toString(QUrl::RemoveUserInfo));

    addCompleterEntry(url);

}

void LauncherWindow::showLinkHover(const QString &link, const QString &toolTip)

{

#ifndef Q_WS_MAEMO_5

    statusBar()->showMessage(link);