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

**

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

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbWidgets module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** 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 developer.feedback@nokia.com.

**

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

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Hb API.  It exists purely as an

// implementation detail.  This file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include "hbabstractedit_p.h"

#include "hbabstractedit.h"

#include "hbstyleoption_p.h"

#include "hbscrollarea.h"

#include "hbvalidator.h"

#include "hbmenu.h"

#include "hbselectioncontrol_p.h"

#include "hbcolorscheme.h"

#include "hbsmileyengine_p.h"

#include "hbtextmeasurementutility_p.h"

#include "hbfeaturemanager_r.h"

#include "hbinputeditorinterface.h"

#include "hbinputvkbhost.h"

#include "hbinputmethod.h"

#include "hbinputfocusobject.h"

#include <QValidator>

#include <QTextLayout>

#include <QTextBlock>

#include <QTextList>

#include <QTextTable>

#include <QApplication>

#include <QGraphicsSceneMouseEvent>

#include <QPainter>

#include <QtDebug>

#include <QClipboard>

#include <QInputContext>

#include <QRegExp>

static inline bool firstFramePosLessThanCursorPos(QTextFrame *frame, int position)

{

    return frame->firstPosition() < position;

}

static inline bool cursorPosLessThanLastFramePos(int position, QTextFrame *frame)

{

    return position < frame->lastPosition();

}

static QRectF boundingRectOfFloatsInSelection(const QTextCursor &cursor)

{

    QRectF r;

    QTextFrame *frame = cursor.currentFrame();

    const QList<QTextFrame *> children = frame->childFrames();

    const QList<QTextFrame *>::ConstIterator firstFrame = qLowerBound(children.constBegin(), children.constEnd(),

                                                                      cursor.selectionStart(), firstFramePosLessThanCursorPos);

    const QList<QTextFrame *>::ConstIterator lastFrame = qUpperBound(children.constBegin(), children.constEnd(),

                                                                     cursor.selectionEnd(), cursorPosLessThanLastFramePos);

    for (QList<QTextFrame *>::ConstIterator it = firstFrame; it != lastFrame; ++it) {

        if ((*it)->frameFormat().position() != QTextFrameFormat::InFlow)

            r |= frame->document()->documentLayout()->frameBoundingRect(*it);

    }

    return r;

}

class HbEditItem : public HbWidget

{

public:

    HbEditItem(HbAbstractEdit *parent) : HbWidget(parent), edit(parent)

    {

    	setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true);

    };

    virtual ~HbEditItem() {};

    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)

    {

        Q_UNUSED(widget)

        painter->save();

#ifdef HB_DEBUG_EDITOR_DRAW_RECTS

        painter->setPen(Qt::yellow);

        painter->drawRect(boundingRect().adjusted(3,3,-3,-3));

#endif

        if ( option) {

            edit->drawContents(painter, *option);

        }

        painter->restore();

    }

    void changeEvent(QEvent *event)

    {

        HbWidget::changeEvent(event);

        switch (event->type()) {

        case QEvent::FontChange:

            edit->document()->setDefaultFont(font());

            break;

        default:

            ;

        }

    }

    HbAbstractEdit *edit;

};

static QTextLine currentTextLine(const QTextCursor &cursor)

{

    const QTextBlock block = cursor.block();

    if (!block.isValid())

        return QTextLine();

    const QTextLayout *layout = block.layout();

    if (!layout)

        return QTextLine();

    const int relativePos = cursor.position() - block.position();

    return layout->lineForTextPosition(relativePos);

}

QStringList HbAbstractEditMimeData::formats() const

{

    if (!fragment.isEmpty())

        return QStringList() << QString::fromLatin1("text/plain") << QString::fromLatin1("text/html");

    else

        return QMimeData::formats();

}

QVariant HbAbstractEditMimeData::retrieveData(const QString &mimeType, QVariant::Type type) const

{

    if (!fragment.isEmpty())

        setup();

    return QMimeData::retrieveData(mimeType, type);

}

void HbAbstractEditMimeData::setup() const

{

    HbAbstractEditMimeData *that = const_cast<HbAbstractEditMimeData *>(this);

#ifndef QT_NO_TEXTHTMLPARSER

    that->setData(QLatin1String("text/html"), fragment.toHtml("utf-8").toUtf8());

#endif

    that->setText(fragment.toPlainText());

    fragment = QTextDocumentFragment();

}

HbAbstractEditPrivate::HbAbstractEditPrivate () :

    HbWidgetPrivate(),

    doc(0),

    placeholderDoc(0),

    validator(0),

    imEditInProgress(false),

    imPosition(0),

    imAdded(0),

    imRemoved(0),

    interactionFlags(Qt::TextEditorInteraction),

    tapPosition(-1, -1),

    cursorOn(false),

    preeditCursor(0),

    preeditCursorVisible(true),

    apiCursorVisible(true),

    canvas(0),

    scrollArea(0),

    scrollable(false),

    hadSelectionOnMousePress(false),

    selectionControl(0),

    acceptSignalContentsChange(true),

    acceptSignalContentsChanged(true),

    validRevision(0),

    wasGesture(false),

    smileysEnabled(false),

    smileyEngine(0),

    formatDialog(0),

    updatePrimitivesInProgress(false)

{

}

HbAbstractEditPrivate::~HbAbstractEditPrivate ()

{

}

void HbAbstractEditPrivate::init()

{

    Q_Q(HbAbstractEdit);

    canvas = new HbEditItem(q);

    canvas->setSizePolicy(QSizePolicy::Ignored,QSizePolicy::Ignored);

    setContent(Qt::RichText, QString());

    QTextOption textOption = doc->defaultTextOption();

    textOption.setTextDirection(q->layoutDirection());

    doc->setDefaultTextOption(textOption);

    doc->setUndoRedoEnabled(interactionFlags & Qt::TextEditable);

    updatePaletteFromTheme();

    scrollArea = new HbScrollArea(q);

    scrollArea->setClampingStyle(HbScrollArea::StrictClamping);

    scrollArea->setFrictionEnabled(true);

    scrollArea->setScrollDirections(Qt::Vertical);

    scrollArea->setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

    scrollArea->setContentWidget(canvas);

    scrollArea->setFlag(QGraphicsItem::ItemIsFocusable, false);

    QObject::connect(scrollArea, SIGNAL(scrollingStarted()), q, SLOT(_q_scrollStarted()));

    QObject::connect(scrollArea, SIGNAL(scrollingEnded()), q, SLOT(_q_scrollEnded()));

    QObject::connect(q, SIGNAL(selectionChanged(QTextCursor,QTextCursor)), q, SLOT(_q_selectionChanged()));

    HbStyle::setItemName(scrollArea, QString("text"));

    // These are the default values which are then overridden in subclasses

    // and when different options are enabled.

    q->setFlag(QGraphicsItem::ItemIsFocusable);

    q->setFlag(QGraphicsItem::ItemAcceptsInputMethod);

    q->setFlag(QGraphicsItem::ItemSendsScenePositionChanges);

    q->setFlag(QGraphicsItem::ItemHasNoContents, false);

    q->setFocusPolicy(Qt::StrongFocus);

    q->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    contextMenuShownOn = Hb::ShowTextContextMenuOnSelectionClicked | Hb::ShowTextContextMenuOnLongPress;

    q->grabGesture(Qt::TapGesture);

}

void HbAbstractEditPrivate::updatePaletteFromTheme()

{

    // The link color is used from application's palette

    QColor linkColor = HbColorScheme::color("qtc_view_link_normal");

    QColor linkVisitedColor = HbColorScheme::color("qtc_view_visited_normal");

    QPalette appPal = qApp->palette();

    if (linkColor.isValid()) {

        appPal.setColor(QPalette::Link, linkColor);

    }

    if (linkVisitedColor.isValid()) {

        appPal.setColor(QPalette::LinkVisited, linkVisitedColor);

    }

    qApp->setPalette(appPal);

}

void HbAbstractEditPrivate::setContent(Qt::TextFormat format, const QString &text)

{

    Q_Q(HbAbstractEdit);

    // for localization text support

    QString txt( text );

#ifdef HB_TEXT_MEASUREMENT_UTILITY

    if ( HbFeatureManager::instance()->featureStatus( HbFeatureManager::TextMeasurement ) ) {

        if (text.endsWith(QChar(LOC_TEST_END))) {

            int index = text.indexOf(QChar(LOC_TEST_START));

            q->setProperty( HbTextMeasurementUtilityNameSpace::textIdPropertyName,

                    text.mid(index + 1, text.indexOf(QChar(LOC_TEST_END)) - index - 1) );

            txt = text.left(index);

        }

    }

#endif

    // for use when called from setPlainText. we may want to re-use the currently

    // set char format then.

    const QTextCharFormat charFormatForInsertion = cursor.charFormat();

    bool clearDocument = true;

    if (!doc) {

        connectToNewDocument(new QTextDocument(q));

    }

    bool previousUndoRedoState = doc->isUndoRedoEnabled();

    doc->setUndoRedoEnabled(false);

    // avoid multiple textChanged() signals being emitted

    acceptSignalContentsChanged = false;

    if (!txt.isEmpty()) {

        // clear 'our' cursor for insertion to prevent

        // the emission of the cursorPositionChanged() signal.

        // instead we emit it only once at the end instead of

        // at the end of the document after loading and when

        // positioning the cursor again to the start of the

        // document.

        cursor = QTextCursor();

        if (format == Qt::PlainText) {

            QTextCursor formatCursor(doc);

            formatCursor.beginEditBlock();

            // put the setPlainText and the setCharFormat into one edit block,

            // so that the syntax highlight triggers only /once/ for the entire

            // document, not twice.

            doc->setPlainText(txt);

            formatCursor.select(QTextCursor::Document);

            formatCursor.setCharFormat(charFormatForInsertion);

            formatCursor.endEditBlock();

        } else {

#ifndef QT_NO_TEXTHTMLPARSER

            doc->setHtml(txt);

#else

            doc->setPlainText(txt);

#endif

        }

        cursor = QTextCursor(doc);

    } else if (clearDocument) {

        doc->clear();

    }

    cursor.setCharFormat(charFormatForInsertion);

    doc->setUndoRedoEnabled(previousUndoRedoState);

    acceptSignalContentsChanged = true;

    updateCurrentCharFormat();

    emit q->contentsChanged();

    cursorChanged(HbValidator::CursorChangeFromContentSet);

    doc->setModified(false);

    ensureCursorVisible();

    smileyEngineInstance()->setDocument(doc);

    if(q->isSmileysEnabled()) {

        smileyEngineInstance()->insertSmileys();

    }

}

bool HbAbstractEditPrivate::setFocusToAnchor(const QTextCursor &newCursor)

{

    Q_UNUSED(newCursor);

    return false;

}

bool HbAbstractEditPrivate::setFocusToNextOrPreviousAnchor(bool next)

{

    Q_UNUSED(next);

    return false;

}

bool HbAbstractEditPrivate::findNextPrevAnchor(const QTextCursor& from, bool next, QTextCursor& newAnchor)

{

    Q_UNUSED(from);

    Q_UNUSED(next);

    Q_UNUSED(newAnchor);

    return false;

}

void HbAbstractEditPrivate::setCursorPosition(int pos, QTextCursor::MoveMode mode)

{

    if (cursor.isNull()) {

        cursor = QTextCursor(doc);

    }

    cursor.setPosition(pos, mode);

    ensureCursorVisible();

    cursorChanged(HbValidator::CursorChangeFromMouse);

}

bool HbAbstractEditPrivate::cursorMoveKeyEvent(QKeyEvent *e)

{

#ifdef QT_NO_SHORTCUT

    Q_UNUSED(e);

#endif

    if (cursor.isNull())

        return false;

    QTextCursor::MoveMode mode = QTextCursor::MoveAnchor;

    QTextCursor::MoveOperation op = QTextCursor::NoMove;

    if (false) {

    }

#ifndef QT_NO_SHORTCUT

    if (e == QKeySequence::MoveToNextChar) {

            op = QTextCursor::Right;

    }

    else if (e == QKeySequence::MoveToPreviousChar) {

            op = QTextCursor::Left;

    }

    else if (e == QKeySequence::SelectNextChar) {

           op = QTextCursor::Right;

           mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectPreviousChar) {

            op = QTextCursor::Left;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectNextWord) {

            op = QTextCursor::WordRight;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectPreviousWord) {

            op = QTextCursor::WordLeft;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectStartOfLine) {

            op = QTextCursor::StartOfLine;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectEndOfLine) {

            op = QTextCursor::EndOfLine;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectStartOfBlock) {

            op = QTextCursor::StartOfBlock;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectEndOfBlock) {

            op = QTextCursor::EndOfBlock;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectStartOfDocument) {

            op = QTextCursor::Start;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectEndOfDocument) {

            op = QTextCursor::End;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectPreviousLine) {

            op = QTextCursor::Up;

            mode = QTextCursor::KeepAnchor;

    }

    else if (e == QKeySequence::SelectNextLine) {

            op = QTextCursor::Down;

            mode = QTextCursor::KeepAnchor;

            {

                QTextBlock block = cursor.block();

                QTextLine line = currentTextLine(cursor);

                if (!block.next().isValid()

                    && line.isValid()

                    && line.lineNumber() == block.layout()->lineCount() - 1)

                    op = QTextCursor::End;

            }

    }

    else if (e == QKeySequence::MoveToNextWord) {

            op = QTextCursor::WordRight;

    }

    else if (e == QKeySequence::MoveToPreviousWord) {

            op = QTextCursor::WordLeft;

    }

    else if (e == QKeySequence::MoveToEndOfBlock) {

            op = QTextCursor::EndOfBlock;

    }

    else if (e == QKeySequence::MoveToStartOfBlock) {

            op = QTextCursor::StartOfBlock;

    }

    else if (e == QKeySequence::MoveToNextLine) {

            op = QTextCursor::Down;

    }

    else if (e == QKeySequence::MoveToPreviousLine) {

            op = QTextCursor::Up;

    }

    else if (e == QKeySequence::MoveToPreviousLine) {

            op = QTextCursor::Up;

    }

    else if (e == QKeySequence::MoveToStartOfLine) {

            op = QTextCursor::StartOfLine;

    }

    else if (e == QKeySequence::MoveToEndOfLine) {

            op = QTextCursor::EndOfLine;

    }

    else if (e == QKeySequence::MoveToStartOfDocument) {

            op = QTextCursor::Start;

    }

    else if (e == QKeySequence::MoveToEndOfDocument) {

            op = QTextCursor::End;

    }

#endif // QT_NO_SHORTCUT

    else {

        return false;

    }

    //const QTextCursor oldCursor = cursor;

    bool visualNavigation = cursor.visualNavigation();

    cursor.setVisualNavigation(true);

    cursor.movePosition(op, mode);

    cursor.setVisualNavigation(visualNavigation);

    cursorChanged(HbValidator::CursorChangeFromOperation);

    return true;

}

void HbAbstractEditPrivate::repaintOldAndNewSelection(const QTextCursor &oldSelection)

{

    if (cursor.hasSelection()

        && oldSelection.hasSelection()

        && cursor.currentFrame() == oldSelection.currentFrame()

        && !cursor.hasComplexSelection()

        && !oldSelection.hasComplexSelection()

        && cursor.anchor() == oldSelection.anchor()

        ) {

        QTextCursor differenceSelection(doc);

        differenceSelection.setPosition(oldSelection.position());

        differenceSelection.setPosition(cursor.position(), QTextCursor::KeepAnchor);