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

**

** 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 "qlinecontrol_p.h"

#ifndef QT_NO_LINEEDIT

#include "qabstractitemview.h"

#include "qclipboard.h"

#ifndef QT_NO_ACCESSIBILITY

#include "qaccessible.h"

#endif

#ifndef QT_NO_IM

#include "qinputcontext.h"

#include "qlist.h"

#endif

#include "qapplication.h"

#ifndef QT_NO_GRAPHICSVIEW

#include "qgraphicssceneevent.h"

#endif

QT_BEGIN_NAMESPACE

/*!

    \internal

    Updates the display text based of the current edit text

    If the text has changed will emit displayTextChanged()

*/

void QLineControl::updateDisplayText(bool forceUpdate)

{

    QString orig = m_textLayout.text();

    QString str;

    if (m_echoMode == QLineEdit::NoEcho)

        str = QString::fromLatin1("");

    else

        str = m_text;

    if (m_echoMode == QLineEdit::Password || (m_echoMode == QLineEdit::PasswordEchoOnEdit

                && !m_passwordEchoEditing))

        str.fill(m_passwordCharacter);

    // replace certain non-printable characters with spaces (to avoid

    // drawing boxes when using fonts that don't have glyphs for such

    // characters)

    QChar* uc = str.data();

    for (int i = 0; i < (int)str.length(); ++i) {

        if ((uc[i] < 0x20 && uc[i] != 0x09)

            || uc[i] == QChar::LineSeparator

            || uc[i] == QChar::ParagraphSeparator

            || uc[i] == QChar::ObjectReplacementCharacter)

            uc[i] = QChar(0x0020);

    }

    m_textLayout.setText(str);

    QTextOption option;

    option.setTextDirection(m_layoutDirection);

    option.setFlags(QTextOption::IncludeTrailingSpaces);

    m_textLayout.setTextOption(option);

    m_textLayout.beginLayout();

    QTextLine l = m_textLayout.createLine();

    m_textLayout.endLayout();

    m_ascent = qRound(l.ascent());

    if (str != orig || forceUpdate)

        emit displayTextChanged(str);

}

#ifndef QT_NO_CLIPBOARD

/*!

    \internal

    Copies the currently selected text into the clipboard using the given

    \a mode.

    \note If the echo mode is set to a mode other than Normal then copy

    will not work.  This is to prevent using copy as a method of bypassing

    password features of the line control.

*/

void QLineControl::copy(QClipboard::Mode mode) const

{

    QString t = selectedText();

    if (!t.isEmpty() && m_echoMode == QLineEdit::Normal) {

        disconnect(QApplication::clipboard(), SIGNAL(selectionChanged()), this, 0);

        QApplication::clipboard()->setText(t, mode);

        connect(QApplication::clipboard(), SIGNAL(selectionChanged()),

                   this, SLOT(_q_clipboardChanged()));

    }

}

/*!

    \internal

    Inserts the text stored in the application clipboard into the line

    control.

    \sa insert()

*/

void QLineControl::paste()

{

    QString clip = QApplication::clipboard()->text(QClipboard::Clipboard);

    if (!clip.isEmpty() || hasSelectedText()) {

        separate(); //make it a separate undo/redo command

        insert(clip);

        separate();

    }

}

#endif // !QT_NO_CLIPBOARD

/*!

    \internal

    Handles the behavior for the backspace key or function.

    Removes the current selection if there is a selection, otherwise

    removes the character prior to the cursor position.

    \sa del()

*/

void QLineControl::backspace()

{

    int priorState = m_undoState;

    if (hasSelectedText()) {

        removeSelectedText();

    } else if (m_cursor) {

            --m_cursor;

            if (m_maskData)

                m_cursor = prevMaskBlank(m_cursor);

            QChar uc = m_text.at(m_cursor);

            if (m_cursor > 0 && uc.unicode() >= 0xdc00 && uc.unicode() < 0xe000) {

                // second half of a surrogate, check if we have the first half as well,

                // if yes delete both at once

                uc = m_text.at(m_cursor - 1);

                if (uc.unicode() >= 0xd800 && uc.unicode() < 0xdc00) {

                    internalDelete(true);

                    --m_cursor;

                }

            }

            internalDelete(true);

    }

    finishChange(priorState);

}

/*!

    \internal

    Handles the behavior for the delete key or function.

    Removes the current selection if there is a selection, otherwise

    removes the character after the cursor position.

    \sa del()

*/

void QLineControl::del()

{

    int priorState = m_undoState;

    if (hasSelectedText()) {

        removeSelectedText();

    } else {

        int n = m_textLayout.nextCursorPosition(m_cursor) - m_cursor;

        while (n--)

            internalDelete();

    }

    finishChange(priorState);

}

/*!

    \internal

    Inserts the given \a newText at the current cursor position.

    If there is any selected text it is removed prior to insertion of

    the new text.

*/

void QLineControl::insert(const QString &newText)

{

    int priorState = m_undoState;

    removeSelectedText();

    internalInsert(newText);

    finishChange(priorState);

}

/*!

    \internal

    Clears the line control text.

*/

void QLineControl::clear()

{

    int priorState = m_undoState;

    m_selstart = 0;

    m_selend = m_text.length();

    removeSelectedText();

    separate();

    finishChange(priorState, /*update*/false, /*edited*/false);

}

/*!

    \internal

    Sets \a length characters from the given \a start position as selected.

    The given \a start position must be within the current text for

    the line control.  If \a length characters cannot be selected, then

    the selection will extend to the end of the current text.

*/

void QLineControl::setSelection(int start, int length)

{

    if(start < 0 || start > (int)m_text.length()){

        qWarning("QLineControl::setSelection: Invalid start position");

        return;

    }

    if (length > 0) {

        if (start == m_selstart && start + length == m_selend)

            return;

        m_selstart = start;

        m_selend = qMin(start + length, (int)m_text.length());

        m_cursor = m_selend;

    } else {

        if (start == m_selend && start + length == m_selstart)

            return;

        m_selstart = qMax(start + length, 0);

        m_selend = start;

        m_cursor = m_selstart;

    }

    emit selectionChanged();

    emitCursorPositionChanged();

}

void QLineControl::_q_clipboardChanged()

{

}

void QLineControl::_q_deleteSelected()

{

    if (!hasSelectedText())

        return;

    int priorState = m_undoState;

    emit resetInputContext();

    removeSelectedText();

    separate();

    finishChange(priorState);

}

/*!

    \internal

    Initializes the line control with a starting text value of \a txt.

*/

void QLineControl::init(const QString &txt)

{

    m_text = txt;

    updateDisplayText();

    m_cursor = m_text.length();

}

/*!

    \internal

    Sets the password echo editing to \a editing.  If password echo editing

    is true, then the text of the password is displayed even if the echo

    mode is set to QLineEdit::PasswordEchoOnEdit.  Password echoing editing

    does not affect other echo modes.

*/

void QLineControl::updatePasswordEchoEditing(bool editing)

{

    m_passwordEchoEditing = editing;

    updateDisplayText();

}

/*!

    \internal

    Returns the cursor position of the given \a x pixel value in relation

    to the displayed text.  The given \a betweenOrOn specified what kind

    of cursor position is requested.

*/

int QLineControl::xToPos(int x, QTextLine::CursorPosition betweenOrOn) const

{

    return m_textLayout.lineAt(0).xToCursor(x, betweenOrOn);

}

/*!

    \internal

    Returns the bounds of the current cursor, as defined as a

    between characters cursor.

*/

QRect QLineControl::cursorRect() const

{

    QTextLine l = m_textLayout.lineAt(0);

    int c = m_cursor;

    if (m_preeditCursor != -1)

        c += m_preeditCursor;

    int cix = qRound(l.cursorToX(c));

    int w = m_cursorWidth;

    int ch = l.height() + 1;

    return QRect(cix-5, 0, w+9, ch);

}

/*!

    \internal

    Fixes the current text so that it is valid given any set validators.

    Returns true if the text was changed.  Otherwise returns false.

*/

bool QLineControl::fixup() // this function assumes that validate currently returns != Acceptable

{

#ifndef QT_NO_VALIDATOR

    if (m_validator) {

        QString textCopy = m_text;

        int cursorCopy = m_cursor;

        m_validator->fixup(textCopy);

        if (m_validator->validate(textCopy, cursorCopy) == QValidator::Acceptable) {

            if (textCopy != m_text || cursorCopy != m_cursor)

                internalSetText(textCopy, cursorCopy);

            return true;

        }

    }

#endif

    return false;

}

/*!

    \internal

    Moves the cursor to the given position \a pos.   If \a mark is true will

    adjust the currently selected text.

*/

void QLineControl::moveCursor(int pos, bool mark)

{

    if (pos != m_cursor) {

        separate();

        if (m_maskData)

            pos = pos > m_cursor ? nextMaskBlank(pos) : prevMaskBlank(pos);

    }

    if (mark) {

        int anchor;

        if (m_selend > m_selstart && m_cursor == m_selstart)

            anchor = m_selend;

        else if (m_selend > m_selstart && m_cursor == m_selend)

            anchor = m_selstart;

        else

            anchor = m_cursor;

        m_selstart = qMin(anchor, pos);

        m_selend = qMax(anchor, pos);

        updateDisplayText();

    } else {

        internalDeselect();

    }

    m_cursor = pos;

    if (mark || m_selDirty) {

        m_selDirty = false;

        emit selectionChanged();

    }

    emitCursorPositionChanged();

}

/*!

    \internal

    Applies the given input method event \a event to the text of the line

    control

*/

void QLineControl::processInputMethodEvent(QInputMethodEvent *event)

{

    int priorState = 0;

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

            || event->preeditString() != preeditAreaText()

            || event->replacementLength() > 0;

    bool cursorPositionChanged = false;

    if (isGettingInput) {

        // If any text is being input, remove selected text.

        priorState = m_undoState;

        removeSelectedText();

    }

    int c = m_cursor; // cursor position after insertion of commit string

    if (event->replacementStart() == 0)

        c += event->commitString().length() + qMin(-event->replacementStart(), event->replacementLength());

    m_cursor += event->replacementStart();

    // insert commit string

    if (event->replacementLength()) {

        m_selstart = m_cursor;

        m_selend = m_selstart + event->replacementLength();

        removeSelectedText();

    }

    if (!event->commitString().isEmpty()) {

        insert(event->commitString());

        cursorPositionChanged = true;

    }

    m_cursor = qMin(c, m_text.length());

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

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

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

            m_cursor = qBound(0, a.start + a.length, m_text.length());

            if (a.length) {

                m_selstart = qMax(0, qMin(a.start, m_text.length()));

                m_selend = m_cursor;

                if (m_selend < m_selstart) {

                    qSwap(m_selstart, m_selend);

                }

            } else {

                m_selstart = m_selend = 0;

            }

            cursorPositionChanged = true;

        }

    }

#ifndef QT_NO_IM

    setPreeditArea(m_cursor, event->preeditString());

#endif //QT_NO_IM

    m_preeditCursor = event->preeditString().length();

    m_hideCursor = false;

    QList<QTextLayout::FormatRange> formats;

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

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

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

            m_preeditCursor = a.start;

            m_hideCursor = !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 + m_cursor;

                o.length = a.length;

                o.format = f;

                formats.append(o);

            }

        }

    }

    m_textLayout.setAdditionalFormats(formats);

    updateDisplayText(/*force*/ true);

    if (cursorPositionChanged)

        emitCursorPositionChanged();

    if (isGettingInput)

        finishChange(priorState);

}

/*!

    \internal

    Draws the display text for the line control using the given 

    \a painter, \a clip, and \a offset.  Which aspects of the display text

    are drawn is specified by the given \a flags.

    If the flags contain DrawSelections, then the selection or input mask

    backgrounds and foregrounds will be applied before drawing the text.

    If the flags contain DrawCursor a cursor of the current cursorWidth()

    will be drawn after drawing the text.

    The display text will only be drawn if the flags contain DrawText

*/

void QLineControl::draw(QPainter *painter, const QPoint &offset, const QRect &clip, int flags)

{

    QVector<QTextLayout::FormatRange> selections;

    if (flags & DrawSelections) {

        QTextLayout::FormatRange o;

        if (m_selstart < m_selend) {

            o.start = m_selstart;

            o.length = m_selend - m_selstart;

            o.format.setBackground(m_palette.brush(QPalette::Highlight));

            o.format.setForeground(m_palette.brush(QPalette::HighlightedText));

        } else {

            // mask selection

            if(!m_blinkPeriod || m_blinkStatus){

                o.start = m_cursor;

                o.length = 1;

                o.format.setBackground(m_palette.brush(QPalette::Text));

                o.format.setForeground(m_palette.brush(QPalette::Window));

            }

        }

        selections.append(o);

    }

    if (flags & DrawText)

        m_textLayout.draw(painter, offset, selections, clip);

    if (flags & DrawCursor){