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

**

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

#include <qfont.h>

#include <qpainter.h>

#include <qevent.h>

#include <qdebug.h>

#include <qmime.h>

#include <qdrag.h>

#include <qclipboard.h>

#include <qmenu.h>

#include <qstyle.h>

#include <qtimer.h>

#include "private/qtextdocumentlayout_p.h"

#include "private/qabstracttextdocumentlayout_p.h"

#include "qtextdocument.h"

#include "private/qtextdocument_p.h"

#include "qtextlist.h"

#include "private/qtextcontrol_p.h"

#include <qtextformat.h>

#include <qdatetime.h>

#include <qapplication.h>

#include <limits.h>

#include <qtexttable.h>

#include <qvariant.h>

#include <qinputcontext.h>

#ifndef QT_NO_TEXTEDIT

QT_BEGIN_NAMESPACE

static inline bool shouldEnableInputMethod(QPlainTextEdit *plaintextedit)

{

    return !plaintextedit->isReadOnly();

}

class QPlainTextDocumentLayoutPrivate : public QAbstractTextDocumentLayoutPrivate

{

    Q_DECLARE_PUBLIC(QPlainTextDocumentLayout)

public:

    QPlainTextDocumentLayoutPrivate() {

        mainViewPrivate = 0;

        width = 0;

        maximumWidth = 0;

        maximumWidthBlockNumber = 0;

        blockCount = 1;

        blockUpdate = blockDocumentSizeChanged = false;

        cursorWidth = 1;

        textLayoutFlags = 0;

    }

    qreal width;

    qreal maximumWidth;

    int maximumWidthBlockNumber;

    int blockCount;

    QPlainTextEditPrivate *mainViewPrivate;

    bool blockUpdate;

    bool blockDocumentSizeChanged;

    int cursorWidth;

    int textLayoutFlags;

    void layoutBlock(const QTextBlock &block);

    qreal blockWidth(const QTextBlock &block);

    void relayout();

};

/*! \class QPlainTextDocumentLayout

    \since 4.4

    \brief The QPlainTextDocumentLayout class implements a plain text layout for QTextDocument

    \ingroup richtext-processing

   A QPlainTextDocumentLayout is required for text documents that can

   be display or edited in a QPlainTextEdit. See

   QTextDocument::setDocumentLayout().

   QPlainTextDocumentLayout uses the QAbstractTextDocumentLayout API

   that QTextDocument requires, but redefines it partially in order to

   support plain text better. For instances, it does not operate on

   vertical pixels, but on paragraphs (called blocks) instead. The

   height of a document is identical to the number of paragraphs it

   contains. The layout also doesn't support tables or nested frames,

   or any sort of advanced text layout that goes beyond a list of

   paragraphs with syntax highlighting.

*/

/*!

  Constructs a plain text document layout for the text \a document.

 */

QPlainTextDocumentLayout::QPlainTextDocumentLayout(QTextDocument *document)

    :QAbstractTextDocumentLayout(* new QPlainTextDocumentLayoutPrivate, document) {

}

/*!

  Destructs a plain text document layout.

 */

QPlainTextDocumentLayout::~QPlainTextDocumentLayout() {}

/*!

  \reimp

 */

void QPlainTextDocumentLayout::draw(QPainter *, const PaintContext &)

{

}

/*!

  \reimp

 */

int QPlainTextDocumentLayout::hitTest(const QPointF &, Qt::HitTestAccuracy ) const

{

//     this function is used from

//     QAbstractTextDocumentLayout::anchorAt(), but is not

//     implementable in a plain text document layout, because the

//     layout depends on the top block and top line which depends on

//     the view

    return -1;

}

/*!

  \reimp

 */

int QPlainTextDocumentLayout::pageCount() const

{ return 1; }

/*!

  \reimp

 */

QSizeF QPlainTextDocumentLayout::documentSize() const

{

    Q_D(const QPlainTextDocumentLayout);

    return QSizeF(d->maximumWidth, document()->lineCount());

}

/*!

  \reimp

 */

QRectF QPlainTextDocumentLayout::frameBoundingRect(QTextFrame *) const

{

    Q_D(const QPlainTextDocumentLayout);

    return QRectF(0, 0, qMax(d->width, d->maximumWidth), qreal(INT_MAX));

}

/*!

  \reimp

 */

QRectF QPlainTextDocumentLayout::blockBoundingRect(const QTextBlock &block) const

{

    if (!block.isValid()) { return QRectF(); }

    QTextLayout *tl = block.layout();

    if (!tl->lineCount())

        const_cast<QPlainTextDocumentLayout*>(this)->layoutBlock(block);

    QRectF br;

    if (block.isVisible()) {

        br = QRectF(QPointF(0, 0), tl->boundingRect().bottomRight());

        if (tl->lineCount() == 1)

            br.setWidth(qMax(br.width(), tl->lineAt(0).naturalTextWidth()));

        qreal margin = document()->documentMargin();

        br.adjust(0, 0, margin, 0);

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

            br.adjust(0, 0, 0, margin);

    }

    return br;

}

/*!

  Ensures that \a block has a valid layout

 */

void QPlainTextDocumentLayout::ensureBlockLayout(const QTextBlock &block) const

{

    if (!block.isValid())

        return;

    QTextLayout *tl = block.layout();

    if (!tl->lineCount())

        const_cast<QPlainTextDocumentLayout*>(this)->layoutBlock(block);

}

/*! \property QPlainTextDocumentLayout::cursorWidth

    This property specifies the width of the cursor in pixels. The default value is 1.

*/

void QPlainTextDocumentLayout::setCursorWidth(int width)

{

    Q_D(QPlainTextDocumentLayout);

    d->cursorWidth = width;

}

int QPlainTextDocumentLayout::cursorWidth() const

{

    Q_D(const QPlainTextDocumentLayout);

    return d->cursorWidth;

}

QPlainTextDocumentLayoutPrivate *QPlainTextDocumentLayout::priv() const

{

    Q_D(const QPlainTextDocumentLayout);

    return const_cast<QPlainTextDocumentLayoutPrivate*>(d);

}

/*!

   Requests a complete update on all views.

 */

void QPlainTextDocumentLayout::requestUpdate()

{

    emit update(QRectF(0., -document()->documentMargin(), 1000000000., 1000000000.));

}

void QPlainTextDocumentLayout::setTextWidth(qreal newWidth)

{

    Q_D(QPlainTextDocumentLayout);

    d->width = d->maximumWidth = newWidth;

    d->relayout();

}

qreal QPlainTextDocumentLayout::textWidth() const

{

    Q_D(const QPlainTextDocumentLayout);

    return d->width;

}

void QPlainTextDocumentLayoutPrivate::relayout()

{

    Q_Q(QPlainTextDocumentLayout);

    QTextBlock block = q->document()->firstBlock();

    while (block.isValid()) {

        block.layout()->clearLayout();

        block.setLineCount(block.isVisible() ? 1 : 0);

        block = block.next();

    }

    emit q->update();

}

/*! \reimp

 */

void QPlainTextDocumentLayout::documentChanged(int from, int /*charsRemoved*/, int charsAdded)

{

    Q_D(QPlainTextDocumentLayout);

    QTextDocument *doc = document();

    int newBlockCount = doc->blockCount();

    QTextBlock changeStartBlock = doc->findBlock(from);

    QTextBlock changeEndBlock = doc->findBlock(qMax(0, from + charsAdded - 1));

    if (changeStartBlock == changeEndBlock && newBlockCount == d->blockCount) {

        QTextBlock block = changeStartBlock;

        int blockLineCount = block.layout()->lineCount();

        if (block.isValid() && blockLineCount) {

            QRectF oldBr = blockBoundingRect(block);

            layoutBlock(block);

            QRectF newBr = blockBoundingRect(block);

            if (newBr.height() == oldBr.height()) {

                if (!d->blockUpdate)

                    emit updateBlock(block);

                return;

            }

        }

    } else {

        QTextBlock block = changeStartBlock;

        do {

            block.clearLayout();

            if (block == changeEndBlock)

                break;

            block = block.next();

        } while(block.isValid());

    }

    if (newBlockCount != d->blockCount) {

        int changeEnd = changeEndBlock.blockNumber();

        int blockDiff = newBlockCount - d->blockCount;

        int oldChangeEnd = changeEnd - blockDiff;

        if (d->maximumWidthBlockNumber > oldChangeEnd)

            d->maximumWidthBlockNumber += blockDiff;

        d->blockCount = newBlockCount;

        if (d->blockCount == 1)

            d->maximumWidth = blockWidth(doc->firstBlock());

        if (!d->blockDocumentSizeChanged)

            emit documentSizeChanged(documentSize());

        if (blockDiff == 1 && changeEnd == newBlockCount -1 ) {

            if (!d->blockUpdate) {

                QTextBlock b = changeStartBlock;

                for(;;) {

                    emit updateBlock(b);

                    if (b == changeEndBlock)

                        break;

                    b = b.next();

                }

            }

            return;

        }

    }

    if (!d->blockUpdate)

	emit update(QRectF(0., -doc->documentMargin(), 1000000000., 1000000000.)); // optimization potential

}

void QPlainTextDocumentLayout::layoutBlock(const QTextBlock &block)

{

    Q_D(QPlainTextDocumentLayout);

    QTextDocument *doc = document();

    qreal margin = doc->documentMargin();

    qreal blockMaximumWidth = 0;

    qreal height = 0;

    QTextLayout *tl = block.layout();

    QTextOption option = doc->defaultTextOption();

    tl->setTextOption(option);

    int extraMargin = 0;

    if (option.flags() & QTextOption::AddSpaceForLineAndParagraphSeparators) {

        QFontMetrics fm(block.charFormat().font());

        extraMargin += fm.width(QChar(0x21B5));

    }

    tl->beginLayout();

    qreal availableWidth = d->width;

    if (availableWidth <= 0) {

        availableWidth = qreal(INT_MAX); // similar to text edit with pageSize.width == 0

    }

    availableWidth -= 2*margin + extraMargin;

    while (1) {

        QTextLine line = tl->createLine();

        if (!line.isValid())

            break;

        line.setLeadingIncluded(true);

        line.setLineWidth(availableWidth);

        line.setPosition(QPointF(margin, height));

        height += line.height();

        blockMaximumWidth = qMax(blockMaximumWidth, line.naturalTextWidth() + 2*margin);

    }

    tl->endLayout();

    int previousLineCount = doc->lineCount();

    const_cast<QTextBlock&>(block).setLineCount(block.isVisible() ? tl->lineCount() : 0);

    int lineCount = doc->lineCount();

    bool emitDocumentSizeChanged = previousLineCount != lineCount;

    if (blockMaximumWidth > d->maximumWidth) {

        // new longest line

        d->maximumWidth = blockMaximumWidth;

        d->maximumWidthBlockNumber = block.blockNumber();

        emitDocumentSizeChanged = true;

    } else if (block.blockNumber() == d->maximumWidthBlockNumber && blockMaximumWidth < d->maximumWidth) {

        // longest line shrinking

        QTextBlock b = doc->firstBlock();

        d->maximumWidth = 0;

        QTextBlock maximumBlock;

        while (b.isValid()) {

            qreal blockMaximumWidth = blockWidth(b);

            if (blockMaximumWidth > d->maximumWidth) {

                d->maximumWidth = blockMaximumWidth;

                maximumBlock = b;

            }

            b = b.next();

        }

        if (maximumBlock.isValid()) {

            d->maximumWidthBlockNumber = maximumBlock.blockNumber();

            emitDocumentSizeChanged = true;

        }

    }

    if (emitDocumentSizeChanged && !d->blockDocumentSizeChanged)

        emit documentSizeChanged(documentSize());

}

qreal QPlainTextDocumentLayout::blockWidth(const QTextBlock &block)

{

    QTextLayout *layout = block.layout();

    if (!layout->lineCount())

        return 0; // only for layouted blocks

    qreal blockWidth = 0;

    for (int i = 0; i < layout->lineCount(); ++i) {

        QTextLine line = layout->lineAt(i);

        blockWidth = qMax(line.naturalTextWidth() + 8, blockWidth);

    }

    return blockWidth;

}

QPlainTextEditControl::QPlainTextEditControl(QPlainTextEdit *parent)

    : QTextControl(parent), textEdit(parent),

      topBlock(0)

{

    setAcceptRichText(false);

}

void QPlainTextEditPrivate::_q_cursorPositionChanged()

{

    pageUpDownLastCursorYIsValid = false;

}

void QPlainTextEditPrivate::_q_verticalScrollbarActionTriggered(int action) {

    if (action == QAbstractSlider::SliderPageStepAdd) {

        pageUpDown(QTextCursor::Down, QTextCursor::MoveAnchor, false);

    } else if (action == QAbstractSlider::SliderPageStepSub) {

        pageUpDown(QTextCursor::Up, QTextCursor::MoveAnchor, false);

    }

}

QMimeData *QPlainTextEditControl::createMimeDataFromSelection() const {

        QPlainTextEdit *ed = qobject_cast<QPlainTextEdit *>(parent());

        if (!ed)

            return QTextControl::createMimeDataFromSelection();

        return ed->createMimeDataFromSelection();

    }

bool QPlainTextEditControl::canInsertFromMimeData(const QMimeData *source) const {

    QPlainTextEdit *ed = qobject_cast<QPlainTextEdit *>(parent());

    if (!ed)

        return QTextControl::canInsertFromMimeData(source);

    return ed->canInsertFromMimeData(source);

}

void QPlainTextEditControl::insertFromMimeData(const QMimeData *source) {

    QPlainTextEdit *ed = qobject_cast<QPlainTextEdit *>(parent());

    if (!ed)

        QTextControl::insertFromMimeData(source);

    else

        ed->insertFromMimeData(source);

}

int QPlainTextEditPrivate::verticalOffset(int topBlock, int topLine) const

{

    qreal offset = 0;

    QTextDocument *doc = control->document();

    if (topLine) {

        QTextBlock currentBlock = doc->findBlockByNumber(topBlock);

        QPlainTextDocumentLayout *documentLayout = qobject_cast<QPlainTextDocumentLayout*>(doc->documentLayout());

        Q_ASSERT(documentLayout);

        QRectF r = documentLayout->blockBoundingRect(currentBlock);

        QTextLayout *layout = currentBlock.layout();

        if (layout && topLine <= layout->lineCount()) {

            QTextLine line = layout->lineAt(topLine - 1);

            const QRectF lr = line.naturalTextRect();

            offset = lr.bottom();

        }

    }

    if (topBlock == 0 && topLine == 0)

        offset -= doc->documentMargin(); // top margin

    return (int)offset;

}

int QPlainTextEditPrivate::verticalOffset() const {

    return verticalOffset(control->topBlock, topLine);

}

QTextBlock QPlainTextEditControl::firstVisibleBlock() const

{

    return document()->findBlockByNumber(topBlock);

}

int QPlainTextEditControl::hitTest(const QPointF &point, Qt::HitTestAccuracy ) const {

    int currentBlockNumber = topBlock;

    QTextBlock currentBlock = document()->findBlockByNumber(currentBlockNumber);

    if (!currentBlock.isValid())

        return -1;

    QPlainTextDocumentLayout *documentLayout = qobject_cast<QPlainTextDocumentLayout*>(document()->documentLayout());

    Q_ASSERT(documentLayout);

    QPointF offset;

    QRectF r = documentLayout->blockBoundingRect(currentBlock);

    while (currentBlock.next().isValid() && r.bottom() + offset.y() <= point.y()) {

        offset.ry() += r.height();

        currentBlock = currentBlock.next();

        ++currentBlockNumber;

        r = documentLayout->blockBoundingRect(currentBlock);

    }

    while (currentBlock.previous().isValid() && r.top() + offset.y() > point.y()) {