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

**

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

** All rights reserved.

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

**

** This file is part of the QtGui module 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 "qtextbrowser.h"

#include "qtextedit_p.h"

#ifndef QT_NO_TEXTBROWSER

#include <qstack.h>

#include <qapplication.h>

#include <qevent.h>

#include <qdesktopwidget.h>

#include <qdebug.h>

#include <qabstracttextdocumentlayout.h>

#include "private/qtextdocumentlayout_p.h"

#include <qtextcodec.h>

#include <qpainter.h>

#include <qdir.h>

#include <qwhatsthis.h>

#include <qtextobject.h>

#include <qdesktopservices.h>

QT_BEGIN_NAMESPACE

class QTextBrowserPrivate : public QTextEditPrivate

{

    Q_DECLARE_PUBLIC(QTextBrowser)

public:

    inline QTextBrowserPrivate()

        : textOrSourceChanged(false), forceLoadOnSourceChange(false), openExternalLinks(false),

          openLinks(true)

#ifdef QT_KEYPAD_NAVIGATION

        , lastKeypadScrollValue(-1)

#endif

    {}

    void init();

    struct HistoryEntry {

        inline HistoryEntry()

            : hpos(0), vpos(0), focusIndicatorPosition(-1),

              focusIndicatorAnchor(-1) {}

        QUrl url;

        QString title;

        int hpos;

        int vpos;

        int focusIndicatorPosition, focusIndicatorAnchor;

    };

    HistoryEntry history(int i) const

    {

        if (i <= 0)

            if (-i < stack.count())

                return stack[stack.count()+i-1];

            else

                return HistoryEntry();

        else

            if (i <= forwardStack.count())

                return forwardStack[forwardStack.count()-i];

            else

                return HistoryEntry();

    }

    HistoryEntry createHistoryEntry() const;

    void restoreHistoryEntry(const HistoryEntry entry);

    QStack<HistoryEntry> stack;

    QStack<HistoryEntry> forwardStack;

    QUrl home;

    QUrl currentURL;

    QStringList searchPaths;

    /*flag necessary to give the linkClicked() signal some meaningful

      semantics when somebody connected to it calls setText() or

      setSource() */

    bool textOrSourceChanged;

    bool forceLoadOnSourceChange;

    bool openExternalLinks;

    bool openLinks;

#ifndef QT_NO_CURSOR

    QCursor oldCursor;

#endif

    QString findFile(const QUrl &name) const;

    inline void _q_documentModified()

    {

        textOrSourceChanged = true;

        forceLoadOnSourceChange = !currentURL.path().isEmpty();

    }

    void _q_activateAnchor(const QString &href);

    void _q_highlightLink(const QString &href);

    void setSource(const QUrl &url);

    // re-imlemented from QTextEditPrivate

    virtual QUrl resolveUrl(const QUrl &url) const;

    inline QUrl resolveUrl(const QString &url) const

    { return resolveUrl(QUrl::fromEncoded(url.toUtf8())); }

#ifdef QT_KEYPAD_NAVIGATION

    void keypadMove(bool next);

    QTextCursor prevFocus;

    int lastKeypadScrollValue;

#endif

};

QString QTextBrowserPrivate::findFile(const QUrl &name) const

{

    QString fileName;

    if (name.scheme() == QLatin1String("qrc"))

        fileName = QLatin1String(":/") + name.path();

    else

        fileName = name.toLocalFile();

    if (QFileInfo(fileName).isAbsolute())

        return fileName;

    foreach (QString path, searchPaths) {

        if (!path.endsWith(QLatin1Char('/')))

            path.append(QLatin1Char('/'));

        path.append(fileName);

        if (QFileInfo(path).isReadable())

            return path;

    }

    return fileName;

}

QUrl QTextBrowserPrivate::resolveUrl(const QUrl &url) const

{

    if (!url.isRelative())

        return url;

    // For the second case QUrl can merge "#someanchor" with "foo.html"

    // correctly to "foo.html#someanchor"

    if (!(currentURL.isRelative()

          || (currentURL.scheme() == QLatin1String("file")

              && !QFileInfo(currentURL.toLocalFile()).isAbsolute()))

          || (url.hasFragment() && url.path().isEmpty())) {

        return currentURL.resolved(url);

    }

    // this is our last resort when current url and new url are both relative

    // we try to resolve against the current working directory in the local

    // file system.

    QFileInfo fi(currentURL.toLocalFile());

    if (fi.exists()) {

        return QUrl::fromLocalFile(fi.absolutePath() + QDir::separator()).resolved(url);

    }

    return url;

}

void QTextBrowserPrivate::_q_activateAnchor(const QString &href)

{

    if (href.isEmpty())

        return;

    Q_Q(QTextBrowser);

#ifndef QT_NO_CURSOR

    viewport->setCursor(oldCursor);

#endif

    const QUrl url = resolveUrl(href);

    if (!openLinks) {

        emit q->anchorClicked(url);

        return;

    }

    textOrSourceChanged = false;

#ifndef QT_NO_DESKTOPSERVICES

    if ((openExternalLinks

         && url.scheme() != QLatin1String("file")

         && url.scheme() != QLatin1String("qrc")

         && !url.isRelative())

        || (url.isRelative() && !currentURL.isRelative()

            && currentURL.scheme() != QLatin1String("file")

            && currentURL.scheme() != QLatin1String("qrc"))) {

        QDesktopServices::openUrl(url);

        return;

    }

#endif

    emit q->anchorClicked(url);

    if (textOrSourceChanged)

        return;

    q->setSource(url);

}

void QTextBrowserPrivate::_q_highlightLink(const QString &anchor)

{

    Q_Q(QTextBrowser);

    if (anchor.isEmpty()) {

#ifndef QT_NO_CURSOR

        if (viewport->cursor().shape() != Qt::PointingHandCursor)

            oldCursor = viewport->cursor();

        viewport->setCursor(oldCursor);

#endif

        emit q->highlighted(QUrl());

        emit q->highlighted(QString());

    } else {

#ifndef QT_NO_CURSOR

        viewport->setCursor(Qt::PointingHandCursor);

#endif

        const QUrl url = resolveUrl(anchor);

        emit q->highlighted(url);

        // convenience to ease connecting to QStatusBar::showMessage(const QString &)

        emit q->highlighted(url.toString());

    }

}

void QTextBrowserPrivate::setSource(const QUrl &url)

{

    Q_Q(QTextBrowser);

#ifndef QT_NO_CURSOR

    if (q->isVisible())

        QApplication::setOverrideCursor(Qt::WaitCursor);

#endif

    textOrSourceChanged = true;

    QString txt;

    bool doSetText = false;

    QUrl currentUrlWithoutFragment = currentURL;

    currentUrlWithoutFragment.setFragment(QString());

    QUrl newUrlWithoutFragment = currentURL.resolved(url);

    newUrlWithoutFragment.setFragment(QString());

    if (url.isValid()

        && (newUrlWithoutFragment != currentUrlWithoutFragment || forceLoadOnSourceChange)) {

        QVariant data = q->loadResource(QTextDocument::HtmlResource, resolveUrl(url));

        if (data.type() == QVariant::String) {

            txt = data.toString();

        } else if (data.type() == QVariant::ByteArray) {

#ifndef QT_NO_TEXTCODEC

            QByteArray ba = data.toByteArray();

            QTextCodec *codec = Qt::codecForHtml(ba);

            txt = codec->toUnicode(ba);

#else

	    txt = data.toString();

#endif

        }

        if (txt.isEmpty())

            qWarning("QTextBrowser: No document for %s", url.toString().toLatin1().constData());

        if (q->isVisible()) {

            QString firstTag = txt.left(txt.indexOf(QLatin1Char('>')) + 1);

            if (firstTag.startsWith(QLatin1String("<qt")) && firstTag.contains(QLatin1String("type")) && firstTag.contains(QLatin1String("detail"))) {

#ifndef QT_NO_CURSOR

                QApplication::restoreOverrideCursor();

#endif

#ifndef QT_NO_WHATSTHIS

                QWhatsThis::showText(QCursor::pos(), txt, q);

#endif

                return;

            }

        }

        currentURL = resolveUrl(url);

        doSetText = true;

    }

    if (!home.isValid())

        home = url;

    if (doSetText) {

#ifndef QT_NO_TEXTHTMLPARSER

        q->QTextEdit::setHtml(txt);

        q->document()->setMetaInformation(QTextDocument::DocumentUrl, currentURL.toString());

#else

        q->QTextEdit::setPlainText(txt);

#endif

#ifdef QT_KEYPAD_NAVIGATION

        prevFocus.movePosition(QTextCursor::Start);

#endif

    }

    forceLoadOnSourceChange = false;

    if (!url.fragment().isEmpty()) {

        q->scrollToAnchor(url.fragment());

    } else {

        hbar->setValue(0);

        vbar->setValue(0);

    }

#ifdef QT_KEYPAD_NAVIGATION

    lastKeypadScrollValue = vbar->value();

    emit q->highlighted(QUrl());

    emit q->highlighted(QString());

#endif

#ifndef QT_NO_CURSOR

    if (q->isVisible())

        QApplication::restoreOverrideCursor();

#endif

    emit q->sourceChanged(url);

}

#ifdef QT_KEYPAD_NAVIGATION

void QTextBrowserPrivate::keypadMove(bool next)

{

    Q_Q(QTextBrowser);

    const int height = viewport->height();

    const int overlap = qBound(20, height / 5, 40); // XXX arbitrary, but a good balance

    const int visibleLinkAmount = overlap; // consistent, but maybe not the best choice (?)

    int yOffset = vbar->value();

    int scrollYOffset = qBound(0, next ? yOffset + height - overlap : yOffset - height + overlap, vbar->maximum());

    bool foundNextAnchor = false;

    bool focusIt = false;

    int focusedPos = -1;

    QTextCursor anchorToFocus;

    QRectF viewRect = QRectF(0, yOffset, control->size().width(), height);

    QRectF newViewRect = QRectF(0, scrollYOffset, control->size().width(), height);

    QRectF bothViewRects = viewRect.united(newViewRect);

    // If we don't have a previous anchor, pretend that we had the first/last character

    // on the screen selected.

    if (prevFocus.isNull()) {

        if (next)

            prevFocus = control->cursorForPosition(QPointF(0, yOffset));

        else

            prevFocus = control->cursorForPosition(QPointF(control->size().width(), yOffset + height));

    }

    // First, check to see if someone has moved the scroll bars independently

    if (lastKeypadScrollValue != yOffset) {

        // Someone (user or programmatically) has moved us, so we might

        // need to start looking from the current position instead of prevFocus

        bool findOnScreen = true;

        // If prevFocus is on screen at all, we just use it.

        if (prevFocus.hasSelection()) {

            QRectF prevRect = control->selectionRect(prevFocus);

            if (viewRect.intersects(prevRect))

                findOnScreen = false;

        }

        // Otherwise, we find a new anchor that's on screen.

        // Basically, create a cursor with the last/first character

        // on screen

        if (findOnScreen) {

            if (next)

                prevFocus = control->cursorForPosition(QPointF(0, yOffset));

            else

                prevFocus = control->cursorForPosition(QPointF(control->size().width(), yOffset + height));

        }

        foundNextAnchor = control->findNextPrevAnchor(prevFocus, next, anchorToFocus);

    } else if (prevFocus.hasSelection()) {

        // Check the pathological case that the current anchor is higher

        // than the screen, and just scroll through it in that case

        QRectF prevRect = control->selectionRect(prevFocus);

        if ((next && prevRect.bottom() > (yOffset + height)) ||

                (!next && prevRect.top() < yOffset)) {

            anchorToFocus = prevFocus;

            focusedPos = scrollYOffset;

            focusIt = true;

        } else {

            // This is the "normal" case - no scroll bar adjustments, no large anchors,

            // and no wrapping.

            foundNextAnchor = control->findNextPrevAnchor(prevFocus, next, anchorToFocus);

        }

    }

    // If not found yet, see if we need to wrap

    if (!focusIt && !foundNextAnchor) {

        if (next) {

            if (yOffset == vbar->maximum()) {

                prevFocus.movePosition(QTextCursor::Start);

                yOffset = scrollYOffset = 0;

                // Refresh the rectangles

                viewRect = QRectF(0, yOffset, control->size().width(), height);

                newViewRect = QRectF(0, scrollYOffset, control->size().width(), height);

                bothViewRects = viewRect.united(newViewRect);

            }

        } else {

            if (yOffset == 0) {

                prevFocus.movePosition(QTextCursor::End);

                yOffset = scrollYOffset = vbar->maximum();

                // Refresh the rectangles

                viewRect = QRectF(0, yOffset, control->size().width(), height);

                newViewRect = QRectF(0, scrollYOffset, control->size().width(), height);

                bothViewRects = viewRect.united(newViewRect);

            }

        }

        // Try looking now

        foundNextAnchor = control->findNextPrevAnchor(prevFocus, next, anchorToFocus);

    }

    // If we did actually find an anchor to use...

    if (foundNextAnchor) {

        QRectF desiredRect = control->selectionRect(anchorToFocus);

        // XXX This is an arbitrary heuristic

        // Decide to focus an anchor if it will be at least be

        // in the middle region of the screen after a scroll.

        // This can result in partial anchors with focus, but

        // insisting on links being completely visible before

        // selecting them causes disparities between links that

        // take up 90% of the screen height and those that take

        // up e.g. 110%

        // Obviously if a link is entirely visible, we still

        // focus it.

        if(bothViewRects.contains(desiredRect)

                || bothViewRects.adjusted(0, visibleLinkAmount, 0, -visibleLinkAmount).intersects(desiredRect)) {

            focusIt = true;

            // We aim to put the new link in the middle of the screen,

            // unless the link is larger than the screen (we just move to

            // display the first page of the link)

            if (desiredRect.height() > height) {

                if (next)

                    focusedPos = (int) desiredRect.top();

                else

                    focusedPos = (int) desiredRect.bottom() - height;

            } else

                focusedPos = (int) ((desiredRect.top() + desiredRect.bottom()) / 2 - (height / 2));

            // and clamp it to make sure we don't skip content.

            if (next)

                focusedPos = qBound(yOffset, focusedPos, scrollYOffset);

            else

                focusedPos = qBound(scrollYOffset, focusedPos, yOffset);

        }

    }

    // If we didn't get a new anchor, check if the old one is still on screen when we scroll

    // Note that big (larger than screen height) anchors also have some handling at the

    // start of this function.

    if (!focusIt && prevFocus.hasSelection()) {

        QRectF desiredRect = control->selectionRect(prevFocus);

        // XXX this may be better off also using the visibleLinkAmount value

        if(newViewRect.intersects(desiredRect)) {

            focusedPos = scrollYOffset;

            focusIt = true;

            anchorToFocus = prevFocus;

        }

    }

    // setTextCursor ensures that the cursor is visible. save & restore

    // the scroll bar values therefore

    const int savedXOffset = hbar->value();

    // Now actually process our decision

    if (focusIt && control->setFocusToAnchor(anchorToFocus)) {

        // Save the focus for next time

        prevFocus = control->textCursor();

        // Scroll

        vbar->setValue(focusedPos);

        lastKeypadScrollValue = focusedPos;

        hbar->setValue(savedXOffset);

        // Ensure that the new selection is highlighted.

        const QString href = control->anchorAtCursor();

        QUrl url = resolveUrl(href);

        emit q->highlighted(url);

        emit q->highlighted(url.toString());

    } else {

        // Scroll

        vbar->setValue(scrollYOffset);

        lastKeypadScrollValue = scrollYOffset;

        // now make sure we don't have a focused anchor

        QTextCursor cursor = control->textCursor();

        cursor.clearSelection();

        control->setTextCursor(cursor);

        hbar->setValue(savedXOffset);

        vbar->setValue(scrollYOffset);