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

**

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

#include "hblineedit_p.h"

#include "hbstyleoption_p.h"

#include "hbscrollarea.h"

#ifdef HB_TEXT_MEASUREMENT_UTILITY

#endif //HB_TEXT_MEASUREMENT_UTILITY

#include "hbevent.h"

#include <QFontMetrics>

#include <QPainter>

#include <QTextBlock>

#include <QTextDocument>

#include <QGraphicsSceneResizeEvent>

#include <QGraphicsLinearLayout>

/*!

 \class HbLineEdit

 \brief HbLineEdit is a one line text editor widget

 @alpha

 @hbwidgets

 A line edit allows the user to enter and edit a single paragraph of plain text.

 The length of the text can be constrained to maxLength().

 You can change the text with setText(). The text is retrieved with text().

 The content in \ref HbLineEdit can be split visually into several lines. 

 In other words the content of the editor can be seen in several lines but it 

 does not contain any linefeeds (e.g. a number of email recipients separated with semicolon). 

 In the API there is a group of methods to support this. 

 If maxRows() is greater than minRows() the

 editor is expandable and it changes its size based on the content between min and max values. 

 Editor expandability can be checked with isExpandable().

 When the text changes the textChanged() signal is emitted.

 When the cursor is moved the cursorPositionChanged() signal is emitted.

 When editing is finished, either because the line edit lost focus or Return/Enter is pressed

 the editingFinished() signal is emitted.

  Echo mode controls how input to editors is shown in the screen. It is by default \b Normal. 

  Other possible modes are \b NoEcho, \b Password, and \b PasswordEchoOnEdit. 

 The frame can be styled using "P_LineEdit_frame" primitive in HbStyle. Text item is not

  replaceable but it can be styled.

 */

/*!

 \fn void HbLineEdit::editingFinished()

 This signal is emitted when the line edit loses focus or Return/Enter is pressed.

 */

/*!

    \fn void HbLineEdit::textChanged(const QString &text)

    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 setText().

    Note: this signal is not emitted when the editor is in any of password modes, \sa echoMode()

*/

/*!

    \fn void void HbLineEdit::selectionChanged()

    This signal is emitted when selection changes.

*/

/*!

 Constructs an empty HbLineEdit with parent \a parent.

 */

HbLineEdit::HbLineEdit (QGraphicsItem *parent) :

    HbAbstractEdit(*new HbLineEditPrivate, parent)

{

    Q_D(HbLineEdit);

    d->q_ptr = this;

    d->init();

}

/*!

 Constructs a HbLineEdit with parent \a parent.

 The text edit will display the text \a text.

 The text is interpreted as plain text.

 */

HbLineEdit::HbLineEdit (const QString &text, QGraphicsItem *parent) :

    HbAbstractEdit(*new HbLineEditPrivate, parent)

{

    Q_D(HbLineEdit);

    d->q_ptr = this;

    d->init();

    if ( !text.isEmpty() ) {

        setText(text);

    }

}

/*!

 Constructs a HbLineEdit with parent \a parent.

 The text edit will use given private implementation \a dd.

 */

HbLineEdit::HbLineEdit (HbLineEditPrivate &dd, QGraphicsItem *parent) :

    HbAbstractEdit(dd, parent)

{

    Q_D(HbLineEdit);

    d->q_ptr = this;

    d->init();

}

/*!

 Destructor.

 */

HbLineEdit::~HbLineEdit ()

{

}

/*!

 Returns current maximum character length in edit.

 \sa setMaxLength

 */

int HbLineEdit::maxLength () const

{

    Q_D(const HbLineEdit);

    return d->maxLength;

}

/*!

 Sets edit maximum character length to \a length.

 If the text is too long, it is truncated at the limit.

 If truncation occurs any selected text will be unselected.

 By default, this property contains a value of -1 (unlimited).

 */

void HbLineEdit::setMaxLength (int length)

{

    Q_D(HbLineEdit);

    if (length < -1) return; // not allowed.

    if (d->maxLength != length) {

        d->maxLength = length;

        d->validateMaxLength();

    }

}

/*!

 Sets the minimum number of editor rows.

 \sa minRows

 */

void HbLineEdit::setMinRows (int rows)

{

    Q_D(HbLineEdit);

    d->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMin, true);

    if (rows<=0) {

        qWarning("HbLineEdit::setMinRows wrong argument, value \"%d\" has been ignored.",

                 rows);

        return;

    }

    if (rows != d->minimumRows) {

        d->minimumRows = rows;

        if (d->minimumRows > d->maximumRows) {

            d->maximumRows = d->minimumRows;

        }

        d->updateWrappingMode();

        if (d->adjustFontSizeToFitHeight) {

            d->readjustStretchFont();

        } else {

            updateGeometry();

        }

    }

}

/*!

 Returns the minimum number of editor rows.

 \sa setMinRows

 */

int HbLineEdit::minRows () const

{

    Q_D(const HbLineEdit);

    return d->minimumRows;

}

/*!

 .Tells whether the editor is expandable or fixed.

 */

bool HbLineEdit::isExpandable () const

{

    Q_D(const HbLineEdit);

    return d->maximumRows > d->minimumRows;

}

/*!

 Sets the maximum number of editor rows to \a rows.

 \sa maxRows

*/

void HbLineEdit::setMaxRows (int rows)

{

    Q_D(HbLineEdit);

    d->setApiProtectionFlag(HbWidgetBasePrivate::AC_TextLinesMax, true);

    if (rows<=0) {

        qWarning("HbLineEdit::setMaxRows wrong argument, value \"%d\" has been ignored.",

                 rows);

        return;

    }

    if (rows != d->maximumRows) {

        d->maximumRows = rows;

        if (d->maximumRows  < d->minimumRows) {

            d->minimumRows = d->maximumRows;

        }

        d->updateWrappingMode();

        if (d->adjustFontSizeToFitHeight) {

            d->readjustStretchFont();

        } else {

            updateGeometry();

        }

#ifdef HB_TEXT_MEASUREMENT_UTILITY

            setProperty( HbTextMeasurementUtilityNameSpace::textMaxLines, d->maximumRows );

        }

#endif

    }

}

/*!

 Returns the maximum number of editor rows.

 \sa setMaxRows

 */

int HbLineEdit::maxRows () const

{

    Q_D(const HbLineEdit);

    return d->maximumRows;

}

/*!

 \reimp

 */

void HbLineEdit::inputMethodEvent(QInputMethodEvent *e)

{

    Q_D(HbLineEdit);

         d->echoMode == HbLineEdit::PasswordEchoOnEdit && d->clearOnEdit) {

        d->doc->clear();

        d->passwordText.clear();

        d->clearOnEdit = false;

    }

    if (e->commitString().contains("\n")) {

        QString str = e->commitString();

        e->setCommitString(str, e->replacementStart(), e->replacementLength());

    }

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

        // change the commit string and update the password string in case we are in password mode

        if(d->echoMode == HbLineEdit::Password) {

            d->passwordText.replace(cursorPosition()+e->replacementStart(), e->replacementLength(), e->commitString());

            e->setCommitString(d->passwordString(e->commitString()), e->replacementStart(), e->replacementLength());

        } else if(d->echoMode == HbLineEdit::NoEcho) {

            d->passwordText.append(e->commitString());

            e->setCommitString("");

        } else if(d->echoMode == HbLineEdit::PasswordEchoOnEdit) {

            // in PasswordEchoOnEdit we still can see what we are typing

            d->passwordText.replace(cursorPosition()+e->replacementStart(), e->replacementLength(), e->commitString());

        }

    }

    HbAbstractEdit::inputMethodEvent(e);

}

/*!

 \reimp

*/

QVariant HbLineEdit::inputMethodQuery(Qt::InputMethodQuery property) const

{

    switch(property) {

    case Qt::ImMaximumTextLength:

        return QVariant(maxLength());

    default:

        return HbAbstractEdit::inputMethodQuery(property);

    }

}

/*!

 \reimp

*/

void HbLineEdit::keyPressEvent (QKeyEvent *event)

{

    Q_D(HbLineEdit);

    if(d->echoMode == HbLineEdit::PasswordEchoOnEdit && d->clearOnEdit) {

        d->doc->clear();

        d->passwordText.clear();

        d->clearOnEdit = false;

    }

    if(d->forwardKeyEvent(event)) {

        HbAbstractEdit::keyPressEvent(event);

        // Keep doc and passwordText in sync

        bool update = false;

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

            update = true;

            d->passwordText.remove(d->passwordText.length()-1,1);

        } else if (!event->text().isEmpty() && event->text().at(0).isPrint()) {

            update = true;

            d->passwordText.append(event->text());

        }

        if (update) {

        }

        setCursorPosition(d->passwordText.length());

    }

}

/*!

 \reimp

 */

void HbLineEdit::keyReleaseEvent (QKeyEvent *event)

{

    Q_D(HbLineEdit);

    if (event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return) {

        d->editingFinished();

    }

    if(d->forwardKeyEvent(event)) {

        HbAbstractEdit::keyReleaseEvent(event);

    }

}

/*!

 \reimp

 */

int HbLineEdit::type () const

{

    return Type;

}

/*!

    Returns the edit's contents as plain text. If smiley recognition is enabled

    all the smiley images will be replaced by their textual representations.

    \sa setText() HbAbstractEdit::setSmileysEnabled()

*/

QString HbLineEdit::text() const

{

    Q_D(const HbLineEdit);

    if(d->isPasswordMode()) {

        return d->passwordText;

    }

    return toPlainText();

}

/*!

    This property holds the displayed text.

    If echoMode is Normal this returns the same as text(); if EchoMode is Password or PasswordEchoOnEdit it

    returns a string of asterisks text().length() characters long, e.g. "******";

    if EchoMode is NoEcho returns an empty string, "".

    By default, this property contains an empty string.

    \sa text()

*/

QString HbLineEdit::displayText() const

{

    return toPlainText();

}

/*!

  Returns true if there is any text section selected in the line edit.

  Otherwise returns false.

  \sa setSelection

 */

bool HbLineEdit::hasSelectedText() const

{

    return textCursor().hasSelection();

}

/*!

 Returns the text that is selected in the line edit.

 If no text section is selected, returns an empty string.

 */

QString HbLineEdit::selectedText() const

{

    return textCursor().selectedText();

}

/*!

  Returns the index of the first selected character in the line

  edit or -1 if no text is selected.

 */

int HbLineEdit::selectionStart () const

{

    if (hasSelectedText()) {

        return textCursor().selectionStart();

    } else {

        return -1;

    }

}

/*!

 Selects text from position \a start and for \a length characters.

 Negative lengths are allowed. Setting the selection fails if

 start position is negative or out of the range of line edit text.

 \sa hasSelectedText

 */

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

{

    int textLength = text().count();

    QString test = text();

    Q_UNUSED(test)

    if (start < 0 || start > textLength) {

        return;

    }

    int end(start+length);

    if (end > textLength) {

        end = textLength;

    } else if (end < 0) {

        end = 0;

    }

    QTextCursor cursor = textCursor();

    cursor.setPosition(start, QTextCursor::MoveAnchor);

    cursor.setPosition(end, QTextCursor::KeepAnchor);

    setTextCursor(cursor);

}

/*!

    Sets cursor position to \a pos.

    \sa cursorPosition

 */

void HbLineEdit::setCursorPosition (int pos)

{

    int length = document()->begin().length();

    if (pos >= length) {

        pos = length-1;

    } else if (pos < 0) {

        pos = 0;

    }

    HbAbstractEdit::setCursorPosition(pos);

}

/*!

    \property HbLineEdit::echoMode

    \brief the line edit's echo mode

    The echo mode determines how the text entered in the line edit is

    displayed (or echoed) to the user.

    The most common setting is \l Normal, in which the text entered by the

    user is displayed verbatim, but HbLineEdit also supports modes that allow

    the entered text to be suppressed or obscured: these include \l NoEcho,

    \l Password and \l PasswordEchoOnEdit.

    The widget's display and the ability to copy or drag the text is

    affected by this setting.

    By default, this property is set to \l Normal.