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

**

** 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.

**

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

#include "hbabstractedit.h"

#include "hbabstractedit_p.h"

#include "hbvalidator.h"

#include "hbstyle.h"

#include "hbstyleoption.h"

#include "hbwidget.h"

#include "hbscrollarea.h"

#include "hbevent.h"

#include <hbwidgetfeedback.h>

#include "hbmenu.h"

#include "hbaction.h"

#include "hbselectioncontrol_p.h"

#include "hbmeshlayout_p.h"

#include "hbsmileyengine.h"

#include "hbinputeditorinterface.h"

#include <QApplication>

#include "hbpopup.h"

#include "hbformatdialog.h"

#include <QTextList>

#include <QFontMetrics>

#include <QGraphicsSceneMouseEvent>

#include <QPainter>

#include <QTextBlock>

#include <QAbstractTextDocumentLayout>

#include <QClipboard>

#include <QInputContext>

/*!

    \class HbAbstractEdit

    \brief HbAbstractEdit is a base class for all text editors.

    @proto

    @hbwidgets

    This is not mentioned as a class to be used directly. All editors inherit this and

    basic functionality is in this class.

    It uses \ref QTextDocument internally to handle the content. And in some editors the document is also exposed to direct access and manipulation.

    \section functionality Functionality this class provides

    \li Editor content: The editor is set read-only with method \ref setReadOnly. Content changes emit a \ref contentsChanged signal.

    \li Cursor position and visibility:  Cursor position can be set with slot \ref setCursorPosition and 

    read with method \ref cursorPosition(). It is also a property. Cursor position changes emit a \ref cursorPositionChanged signal. 

    Cursor visibility can be controlled with \ref setCursorVisibility.

    \li Editing: There is a group of useful methods for editing the content. Clipboard functionality can be found 

    in \ref cut, \ref copy and \paste.  Finishing editing emits a \ref editingFinished signal and text changes 

    emit a \ref textChanged signal. 

    \li Selection handling: Whenever there is a interactive selection special handles are shown which can be used to manipulate the selection. 

    Selection changes emit a \ref selectionChanged signal.

    \li Anchor support: Anchors are strings associated to some a content in editor. There are two \ref anchorAt methods to access the anchors. 

    When user invokes an anchor it will open a context menu that may contain operations related to the anchor item (e.g. creating calls 

    for phone numbers, opening a web browser for web-addresses, etc.). This is always application specific functionality. 

    Editor itself does not create any anchors by examining the content.

    There is also protected API in HbAbstractEdit. Some of these API methods can be exposed as public in more specific editor widgets.

    \li Editor content:  Both rich text and plain text are supported in HbAbstractEdit. Depending on the actual 

    editor widget only one or the other type might be supported. Plain text content is set with 

    method \ref setPlainText. Method \ref toPlainText returns the content converted to plain text. 

    \li Focus control: Editor is responsble for controlling the input panel visibility. In some situations special editor may need to also handle this, but in general it is always handled by HbAbstractEdit. 

    Input panel is closed when editor loses focus.

    \li Cursor control: A convenience method \ref moveCursor can also be used to move the cursor.

    \li Scrolling: When e.g. the size of the content exceeds the size of editor, method \ref setScrollable

    can be used to make the editor scrollable. Method isScrollable tells whether the editor is scrollable or not. 

    Method scrollArea returns the used scroll area widget. Scrolling is enabled by default.

    \li Input validation: The validator for restricting the content input is set with method \ref setValidator. Only \ref HbValidator

    based validators can be used.

    \section composition Widget composition

    Editor widget consists of these sub-items visible in the picture. 

    In this example editor shows only one visible line of the content.

    \image html editor_composition.jpg

    The size of the canvas is always same as the size of the document, and the width of the scroll area 

    is same as the width of the document. The editor margins are defined in the CSS.

*/

/*!

    \fn void HbAbstractEdit::contentsChanged()

    This signal is emitted whenever the text changes. The text argument is the new text.

    This signal is also emitted when the text is changed programmatically, for example,

    by calling setPlainText().

*/

/*!

    \fn void HbAbstractEdit::selectionChanged(const QTextCursor &oldCursor, const QTextCursor &newCursor)

    This signal is emitted whenever the selection changes. */

/*!

    \fn void HbAbstractEdit::cursorPositionChanged(int oldPos, int newPos)

    This signal is emitted when cursor position has been changed.

*/

/*!

    \fn QString HbAbstractEdit::toPlainText() const

    Returns the contents as plain text.

    \sa QTextDocument::toPlainText()

*/

#define Hb_Invalid_Position QPointF(-1.0, -1.0)

/*!

    Constructs a HbAbstractEdit with parent \a parent.

 */

HbAbstractEdit::HbAbstractEdit(QGraphicsItem *parent) :

    HbWidget(*new HbAbstractEditPrivate, parent)

{

    Q_D(HbAbstractEdit);

    d->q_ptr = this;

    d->init();

}

/*!

    Constructs a HbAbstractEdit with abstract edit private object \a dd and parent \a parent.

 */

HbAbstractEdit::HbAbstractEdit(HbAbstractEditPrivate &dd, QGraphicsItem *parent) :

    HbWidget(dd, parent)

{

    Q_D(HbAbstractEdit);

    d->q_ptr = this;

    d->init();

}

/*!

    Destructor.

*/

HbAbstractEdit::~HbAbstractEdit()

{

}

/*!

    \reimp

*/

void HbAbstractEdit::resizeEvent(QGraphicsSceneResizeEvent *event)

{    

    HbWidget::resizeEvent(event);

    updatePrimitives();

}

/*!

    \reimp

*/

bool HbAbstractEdit::event(QEvent* event)

{

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

        const QString p = static_cast<QDynamicPropertyChangeEvent *>(event)->propertyName();

        if(p == "SmileyIcon") {

            Q_D(HbAbstractEdit);

            QString iconName = property("SmileyIcon").toString();

            HbSmileyTheme smileyTheme = d->smileyEngineInstance()->theme();

            QString pattern = smileyTheme.patterns(iconName).first();

            QTextCursor cursor = textCursor();

            int oldPos = cursor.position();

            cursor.insertText(pattern);

            setTextCursor(cursor);

            QTextCursor matchCursor(document());

            matchCursor.setPosition(oldPos);

            d->smileyEngineInstance()->insertSmiley(matchCursor);

            d->cursorChanged(HbValidator::CursorChangeFromContentUpdate);

        }

    }

    return HbWidget::event(event);

}

/*!

    \reimp

*/

bool HbAbstractEdit::eventFilter(QObject *obj, QEvent *e)

{

    Q_D(HbAbstractEdit);

    if (obj == d->scrollArea

        && (e->type() == QEvent::GraphicsSceneMousePress

        || e->type() == QEvent::GraphicsSceneMouseMove

        || e->type() == QEvent::GraphicsSceneMouseRelease)) {

        // map e->pos to the editor's coordinate system

        QGraphicsSceneMouseEvent *event = static_cast<QGraphicsSceneMouseEvent*>(e);

        QPointF oldPos = event->pos();

        event->setPos(mapFromItem(d->scrollArea,oldPos));

        bool ret = sceneEvent(e);

        event->setPos(oldPos);

        return ret;

    }

    return false;

}

QVariant HbAbstractEdit::inputMethodQuery (Qt::InputMethodQuery query) const

{

    Q_D(const HbAbstractEdit);

    QTextBlock block = d->cursor.block();

    switch(query) {

    case Qt::ImMicroFocus:

        return d->cursorRect();

    case Qt::ImFont:

        return QVariant(d->cursor.charFormat().font());

    case Qt::ImCursorPosition:

        return QVariant(d->cursor.position() - block.position());

    case Qt::ImSurroundingText:

        return QVariant(block.text());

    case Qt::ImCurrentSelection:

        return QVariant(d->cursor.selectedText());

    default:

        return QVariant();

    }

}

void HbAbstractEdit::inputMethodEvent (QInputMethodEvent *e)

{

    Q_D(HbAbstractEdit);

    if (!(d->interactionFlags & Qt::TextEditable) || d->cursor.isNull()) {

        e->ignore();

        return;

    }

    QTextBlock block = d->cursor.block();

    QTextLayout *layout = block.layout();

    bool isGettingInput = !e->commitString().isEmpty()

            || e->preeditString() != layout->preeditAreaText()

            || e->replacementLength() > 0;

    d->cursor.beginEditBlock();

    if (isGettingInput) {

        if (!d->imEditInProgress) {

            d->imEditInProgress = true;

            d->imPosition = d->selectionCursor.selectionStart();

            d->imRemoved = d->selectionCursor.selectionEnd() - d->selectionCursor.selectionStart();

        }

        d->selectionCursor.removeSelectedText();

    }

    // insert commit string

    if (!e->commitString().isEmpty() || e->replacementLength()) {

        QTextCursor c = d->cursor;

        c.setPosition(c.position() + e->replacementStart());

        c.setPosition(c.position() + e->replacementLength(), QTextCursor::KeepAnchor);

        QString commitString = e->commitString();

        c.insertText(commitString, d->nextCharCursor.charFormat());

        d->imAdded = commitString.length();

    }

    if (isGettingInput) {

        layout->setPreeditArea(d->cursor.position() - block.position(), e->preeditString());

    }

    QList<QTextLayout::FormatRange> overrides;

    d->preeditCursor = e->preeditString().length();

    d->preeditCursorVisible = true;

    for (int i = 0; i < e->attributes().size(); ++i) {

        const QInputMethodEvent::Attribute &a = e->attributes().at(i);

        if (a.type == QInputMethodEvent::Cursor) {

            d->preeditCursor = a.start;

            d->preeditCursorVisible = a.length;

        } else if (a.type == QInputMethodEvent::TextFormat) {

            QTextCharFormat f = qvariant_cast<QTextFormat>(a.value).toCharFormat();

            if (f.isValid()) {

                QTextLayout::FormatRange o;

                o.start = a.start + d->cursor.position() - block.position();

                o.length = a.length;

                o.format = f;

                overrides.append(o);

            }

        }

    }

    layout->setAdditionalFormats(overrides);

    d->acceptSignalContentsChange = false;

    d->acceptSignalContentsChanged = false;

    d->cursor.endEditBlock();

    d->acceptSignalContentsChange = true;

    d->acceptSignalContentsChanged = true;

    d->cursorChanged(HbValidator::CursorChangeFromContentUpdate);

    // Input method editing is done

    if (!e->commitString().isEmpty() || e->replacementLength()) {

        d->imEditInProgress = false;

        d->imPosition = e->replacementStart();

        d->imAdded = e->commitString().length();

        d->imRemoved =  e->replacementLength();

        d->_q_contentsChanged();

    }

    if(hasFocus()) {

        d->cursorOn = true;

    }

    d->ensureCursorVisible();

}

/*!

    \reimp

*/

void HbAbstractEdit::keyPressEvent(QKeyEvent *event)

{

    Q_D(HbAbstractEdit);

    if (d->interactionFlags & Qt::NoTextInteraction)

        return;

#ifndef QT_NO_SHORTCUT

#ifndef QT_NO_CLIPBOARD

    if (event == QKeySequence::Copy) {

        event->accept();

        copy();

        return;

    }

    else if (event == QKeySequence::Cut) {

        cut();

        d->acceptKeyPressEvent(event);

        return;

    }

    else if (event == QKeySequence::Paste) {

        paste();

        d->acceptKeyPressEvent(event);

        return;

    }

#endif

#endif // QT_NO_SHORTCUT

    if (d->interactionFlags & Qt::TextSelectableByKeyboard

        && d->cursorMoveKeyEvent(event))

        d->acceptKeyPressEvent(event);

    if (!(d->interactionFlags & Qt::TextEditable)) {

        d->repaintOldAndNewSelection(d->selectionCursor);

        d->cursorChanged(HbValidator::CursorChangeFromContentUpdate);

        //ensureCursorVisible();

        event->ignore();

        return;

    }

    if (event->key() == Qt::Key_Direction_L || event->key() == Qt::Key_Direction_R) {

        QTextBlockFormat fmt;

        fmt.setLayoutDirection((event->key() == Qt::Key_Direction_L) ? Qt::LeftToRight : Qt::RightToLeft);

        d->cursor.mergeBlockFormat(fmt);

        d->acceptKeyPressEvent(event);

    }

    // schedule a repaint of the region of the cursor, as when we move it we

    // want to make sure the old cursor disappears (not noticeable when moving

    // only a few pixels but noticeable when jumping between cells in tables for

    // example)

    d->repaintOldAndNewSelection(QTextCursor());

    if (event->key() == Qt::Key_Backspace && !(event->modifiers() & ~Qt::ShiftModifier)) {

        QTextBlockFormat blockFmt = d->cursor.blockFormat();

        QTextList *list = d->cursor.currentList();

        if (list && d->cursor.atBlockStart()) {

            list->remove(d->cursor.block());

        } else if (d->cursor.atBlockStart() && blockFmt.indent() > 0) {

            blockFmt.setIndent(blockFmt.indent() - 1);

            d->cursor.setBlockFormat(blockFmt);

        } else if (d->selectionCursor.hasSelection()) {

            d->selectionCursor.removeSelectedText();

        } else {

            QTextCursor oldCursor(d->cursor);

            oldCursor.deletePreviousChar();

        }

        d->ensureCursorVisible();

    }

#ifndef QT_NO_SHORTCUT

      else if (event == QKeySequence::InsertParagraphSeparator) {

        d->cursor.insertBlock();

        d->acceptKeyPressEvent(event);

    } else if (event == QKeySequence::InsertLineSeparator) {

        d->cursor.insertText(QString(QChar::LineSeparator));

        d->acceptKeyPressEvent(event);

    }

#endif

    if (false) {

    }

#ifndef QT_NO_SHORTCUT

      else if (event == QKeySequence::Delete) {

        d->cursor.deleteChar();

        d->acceptKeyPressEvent(event);

    } else if (event == QKeySequence::DeleteEndOfWord) {

        d->cursor.movePosition(QTextCursor::NextWord, QTextCursor::KeepAnchor);

        d->cursor.removeSelectedText();

        d->acceptKeyPressEvent(event);

    } else if (event == QKeySequence::DeleteStartOfWord) {

        d->cursor.movePosition(QTextCursor::PreviousWord, QTextCursor::KeepAnchor);

        d->cursor.removeSelectedText();

        d->acceptKeyPressEvent(event);

    } else if (event == QKeySequence::DeleteEndOfLine) {

        QTextBlock block = d->cursor.block();

        if (d->cursor.position() == block.position() + block.length() - 2) {

            d->cursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor);

        } else {

            d->cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor);

        }

        d->cursor.removeSelectedText();

        d->acceptKeyPressEvent(event);

    }

#endif // QT_NO_SHORTCUT

    else {

    QString text = event->text();

    if (!text.isEmpty()

        && (text.at(0).isPrint()

        || text.at(0) == QLatin1Char('\t')

        || (d->scrollable

        && (text.at(0) == QLatin1Char('\n')

        || text.at(0) == QLatin1Char('\r'))))) {

            d->cursor.insertText(text, d->nextCharCursor.charFormat());

            d->acceptKeyPressEvent(event);

        }

    }

    d->cursorChanged(HbValidator::CursorChangeFromContentUpdate);

}

/*!

    \reimp

*/

void HbAbstractEdit::keyReleaseEvent (QKeyEvent *event)

{   

    event->accept();

}

/*!

    \reimp

*/

void HbAbstractEdit::mousePressEvent(QGraphicsSceneMouseEvent *event)

{

    Q_D(HbAbstractEdit);

    if (d->selectionControl) {

        d->selectionControl->panStarted();

    }

    if (d->interactionFlags & Qt::NoTextInteraction)

        return;

    if (!(event->button() & Qt::LeftButton))

        return;

    if (!((d->interactionFlags & Qt::TextSelectableByMouse) || (d->interactionFlags & Qt::TextEditable)))

        return;

    d->mousePressPos = event->pos();

    d->wasGesture = false;

    HbWidgetFeedback::triggered(this, Hb::InstantPressed);

//    d->minimizeInputPanel();

    event->accept();

}

/*!

    \reimp

*/

void HbAbstractEdit::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

{

    Q_UNUSED(event)

}

/*!

    \reimp

*/

void HbAbstractEdit::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)

{

    Q_D(HbAbstractEdit);

    if (d->selectionControl) {

        d->selectionControl->panFinished();

    }

    if (d->wasGesture) return;