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

**

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

#include "qtextcursor_p.h"

#include "qglobal.h"

#include "qtextdocumentfragment.h"

#include "qtextdocumentfragment_p.h"

#include "qtextlist.h"

#include "qtexttable.h"

#include "qtexttable_p.h"

#include "qtextengine_p.h"

#include "qabstracttextdocumentlayout.h"

#include <qtextlayout.h>

#include <qdebug.h>

QT_BEGIN_NAMESPACE

enum {

    AdjustPrev = 0x1,

    AdjustUp = 0x3,

    AdjustNext = 0x4,

    AdjustDown = 0x12

};

QTextCursorPrivate::QTextCursorPrivate(QTextDocumentPrivate *p)

    : priv(p), x(0), position(0), anchor(0), adjusted_anchor(0),

      currentCharFormat(-1), visualNavigation(false)

{

    priv->addCursor(this);

}

QTextCursorPrivate::QTextCursorPrivate(const QTextCursorPrivate &rhs)

    : QSharedData(rhs)

{

    position = rhs.position;

    anchor = rhs.anchor;

    adjusted_anchor = rhs.adjusted_anchor;

    priv = rhs.priv;

    x = rhs.x;

    currentCharFormat = rhs.currentCharFormat;

    visualNavigation = rhs.visualNavigation;

    priv->addCursor(this);

}

QTextCursorPrivate::~QTextCursorPrivate()

{

    if (priv)

        priv->removeCursor(this);

}

QTextCursorPrivate::AdjustResult QTextCursorPrivate::adjustPosition(int positionOfChange, int charsAddedOrRemoved, QTextUndoCommand::Operation op)

{

    QTextCursorPrivate::AdjustResult result = QTextCursorPrivate::CursorMoved;

    // not(!) <= , so that inserting text adjusts the cursor correctly

    if (position < positionOfChange

        || (position == positionOfChange

            && (op == QTextUndoCommand::KeepCursor

                || anchor < position)

            )

         ) {

        result = CursorUnchanged;

    } else {

        if (charsAddedOrRemoved < 0 && position < positionOfChange - charsAddedOrRemoved)

            position = positionOfChange;

        else

            position += charsAddedOrRemoved;

        currentCharFormat = -1;

    }

    if (anchor >= positionOfChange

        && (anchor != positionOfChange || op != QTextUndoCommand::KeepCursor)) {

        if (charsAddedOrRemoved < 0 && anchor < positionOfChange - charsAddedOrRemoved)

            anchor = positionOfChange;

        else

            anchor += charsAddedOrRemoved;

    }

    if (adjusted_anchor >= positionOfChange

        && (adjusted_anchor != positionOfChange || op != QTextUndoCommand::KeepCursor)) {

        if (charsAddedOrRemoved < 0 && adjusted_anchor < positionOfChange - charsAddedOrRemoved)

            adjusted_anchor = positionOfChange;

        else

            adjusted_anchor += charsAddedOrRemoved;

    }

    return result;

}

void QTextCursorPrivate::setX()

{

    if (priv->isInEditBlock()) {

        x = -1; // mark dirty

        return;

    }

    QTextBlock block = this->block();

    const QTextLayout *layout = blockLayout(block);

    int pos = position - block.position();

    QTextLine line = layout->lineForTextPosition(pos);

    if (line.isValid())

        x = line.cursorToX(pos);

    else

        x = -1; // delayed init.  Makes movePosition() call setX later on again.

}

void QTextCursorPrivate::remove()

{

    if (anchor == position)

        return;

    currentCharFormat = -1;

    int pos1 = position;

    int pos2 = adjusted_anchor;

    QTextUndoCommand::Operation op = QTextUndoCommand::KeepCursor;

    if (pos1 > pos2) {

        pos1 = adjusted_anchor;

        pos2 = position;

        op = QTextUndoCommand::MoveCursor;

    }

    // deleting inside table? -> delete only content

    QTextTable *table = complexSelectionTable();

    if (table) {

        priv->beginEditBlock();

        int startRow, startCol, numRows, numCols;

        selectedTableCells(&startRow, &numRows, &startCol, &numCols);

        clearCells(table, startRow, startCol, numRows, numCols, op);

        adjusted_anchor = anchor = position;

        priv->endEditBlock();

    } else {

        priv->remove(pos1, pos2-pos1, op);

        adjusted_anchor = anchor = position;

        priv->finishEdit();

    }

}

void QTextCursorPrivate::clearCells(QTextTable *table, int startRow, int startCol, int numRows, int numCols, QTextUndoCommand::Operation op)

{

    priv->beginEditBlock();

    for (int row = startRow; row < startRow + numRows; ++row)

        for (int col = startCol; col < startCol + numCols; ++col) {

            QTextTableCell cell = table->cellAt(row, col);

            const int startPos = cell.firstPosition();

            const int endPos = cell.lastPosition();

            Q_ASSERT(startPos <= endPos);

            priv->remove(startPos, endPos - startPos, op);

        }

    priv->endEditBlock();

}

bool QTextCursorPrivate::canDelete(int pos) const

{

    QTextDocumentPrivate::FragmentIterator fit = priv->find(pos);

    QTextCharFormat fmt = priv->formatCollection()->charFormat((*fit)->format);

    return (fmt.objectIndex() == -1 || fmt.objectType() == QTextFormat::ImageObject);

}

void QTextCursorPrivate::insertBlock(const QTextBlockFormat &format, const QTextCharFormat &charFormat)

{

    QTextFormatCollection *formats = priv->formatCollection();

    int idx = formats->indexForFormat(format);

    Q_ASSERT(formats->format(idx).isBlockFormat());

    priv->insertBlock(position, idx, formats->indexForFormat(charFormat));

    currentCharFormat = -1;

}

void QTextCursorPrivate::adjustCursor(QTextCursor::MoveOperation m)

{

    adjusted_anchor = anchor;

    if (position == anchor)

        return;

    QTextFrame *f_position = priv->frameAt(position);

    QTextFrame *f_anchor = priv->frameAt(adjusted_anchor);

    if (f_position != f_anchor) {

        // find common parent frame

        QList<QTextFrame *> positionChain;

        QList<QTextFrame *> anchorChain;

        QTextFrame *f = f_position;

        while (f) {

            positionChain.prepend(f);

            f = f->parentFrame();

        }

        f = f_anchor;

        while (f) {

            anchorChain.prepend(f);

            f = f->parentFrame();

        }

        Q_ASSERT(positionChain.at(0) == anchorChain.at(0));

        int i = 1;

        int l = qMin(positionChain.size(), anchorChain.size());

        for (; i < l; ++i) {

            if (positionChain.at(i) != anchorChain.at(i))

                break;

        }

        if (m <= QTextCursor::WordLeft) {

            if (i < positionChain.size())

                position = positionChain.at(i)->firstPosition() - 1;

        } else {

            if (i < positionChain.size())

                position = positionChain.at(i)->lastPosition() + 1;

        }

        if (position < adjusted_anchor) {

            if (i < anchorChain.size())

                adjusted_anchor = anchorChain.at(i)->lastPosition() + 1;

        } else {

            if (i < anchorChain.size())

                adjusted_anchor = anchorChain.at(i)->firstPosition() - 1;

        }

        f_position = positionChain.at(i-1);

    }

    // same frame, either need to adjust to cell boundaries or return

    QTextTable *table = qobject_cast<QTextTable *>(f_position);

    if (!table)

        return;

    QTextTableCell c_position = table->cellAt(position);

    QTextTableCell c_anchor = table->cellAt(adjusted_anchor);

    if (c_position != c_anchor) {

        bool before;

        int col_position = c_position.column();

        int col_anchor = c_anchor.column();

        if (col_position == col_anchor) {

            before = c_position.row() < c_anchor.row();

        } else {

            before = col_position < col_anchor;

        }

        // adjust to cell boundaries

        if (m <= QTextCursor::WordLeft) {

            position = c_position.firstPosition();

            if (!before)

                --position;

        } else {

            position = c_position.lastPosition();

            if (before)

                ++position;

        }

        if (position < adjusted_anchor)

            adjusted_anchor = c_anchor.lastPosition();

        else

            adjusted_anchor = c_anchor.firstPosition();

    }

    currentCharFormat = -1;

}

void QTextCursorPrivate::aboutToRemoveCell(int from, int to)

{

    Q_ASSERT(from <= to);

    if (position == anchor)

        return;

    QTextTable *t = qobject_cast<QTextTable *>(priv->frameAt(position));

    if (!t)

        return;

    QTextTableCell removedCellFrom = t->cellAt(from);

    QTextTableCell removedCellEnd = t->cellAt(to);

    if (! removedCellFrom.isValid() || !removedCellEnd.isValid())

        return;

    int curFrom = position;

    int curTo = adjusted_anchor;

    if (curTo < curFrom)

        qSwap(curFrom, curTo);

    QTextTableCell cellStart = t->cellAt(curFrom);

    QTextTableCell cellEnd = t->cellAt(curTo);

    if (cellStart.row() >= removedCellFrom.row() && cellEnd.row() <= removedCellEnd.row()

            && cellStart.column() >= removedCellFrom.column()

              && cellEnd.column() <= removedCellEnd.column()) { // selection is completely removed

        // find a new position, as close as possible to where we were.

        QTextTableCell cell;

        if (removedCellFrom.row() == 0 && removedCellEnd.row() == t->rows()-1) // removed n columns

            cell = t->cellAt(cellStart.row(), removedCellEnd.column()+1);

        else if (removedCellFrom.column() == 0 && removedCellEnd.column() == t->columns()-1) // removed n rows

            cell = t->cellAt(removedCellEnd.row() + 1, cellStart.column());

        int newPosition;

        if (cell.isValid())

            newPosition = cell.firstPosition();

        else

            newPosition = t->lastPosition()+1;

        setPosition(newPosition);

        anchor = newPosition;

        adjusted_anchor = newPosition;

        x = 0;

    }

    else if (cellStart.row() >= removedCellFrom.row() && cellStart.row() <= removedCellEnd.row()

        && cellEnd.row() > removedCellEnd.row()) {

        int newPosition = t->cellAt(removedCellEnd.row() + 1, cellStart.column()).firstPosition();

        if (position < anchor)

            position = newPosition;

        else

            anchor = adjusted_anchor = newPosition;

    }

    else if (cellStart.column() >= removedCellFrom.column() && cellStart.column() <= removedCellEnd.column()

        && cellEnd.column() > removedCellEnd.column()) {

        int newPosition = t->cellAt(cellStart.row(), removedCellEnd.column()+1).firstPosition();

        if (position < anchor)

            position = newPosition;

        else

            anchor = adjusted_anchor = newPosition;

    }

}

bool QTextCursorPrivate::movePosition(QTextCursor::MoveOperation op, QTextCursor::MoveMode mode)

{

    currentCharFormat = -1;

    bool adjustX = true;

    QTextBlock blockIt = block();

    if (op >= QTextCursor::Left && op <= QTextCursor::WordRight

        && blockIt.blockFormat().layoutDirection() == Qt::RightToLeft) {

        if (op == QTextCursor::Left)

            op = QTextCursor::NextCharacter;

        else if (op == QTextCursor::Right)

            op = QTextCursor::PreviousCharacter;

        else if (op == QTextCursor::WordLeft)

            op = QTextCursor::NextWord;

        else if (op == QTextCursor::WordRight)

            op = QTextCursor::PreviousWord;

    }

    const QTextLayout *layout = blockLayout(blockIt);

    int relativePos = position - blockIt.position();

    QTextLine line;

    if (!priv->isInEditBlock())

        line = layout->lineForTextPosition(relativePos);

    Q_ASSERT(priv->frameAt(position) == priv->frameAt(adjusted_anchor));

    int newPosition = position;

    if (x == -1 && !priv->isInEditBlock() && (op == QTextCursor::Up || op == QTextCursor::Down))

        setX();

    switch(op) {

    case QTextCursor::NoMove:

        return true;

    case QTextCursor::Start:

        newPosition = 0;

        break;

    case QTextCursor::StartOfLine: {

        newPosition = blockIt.position();

        if (line.isValid())

            newPosition += line.textStart();

        break;

    }

    case QTextCursor::StartOfBlock: {

        newPosition = blockIt.position();

        break;

    }

    case QTextCursor::PreviousBlock: {

        if (blockIt == priv->blocksBegin())

            return false;

        blockIt = blockIt.previous();

        newPosition = blockIt.position();

        break;

    }

    case QTextCursor::PreviousCharacter:

    case QTextCursor::Left:

        newPosition = priv->previousCursorPosition(position, QTextLayout::SkipCharacters);

        break;

    case QTextCursor::StartOfWord: {

        if (relativePos == 0)

            break;

        // skip if already at word start

        QTextEngine *engine = layout->engine();

        engine->attributes();

        if ((relativePos == blockIt.length() - 1)

            && (engine->atSpace(relativePos - 1) || engine->atWordSeparator(relativePos - 1)))

            return false;

        if (relativePos < blockIt.length()-1)

            ++position;

        // FALL THROUGH!

    }

    case QTextCursor::PreviousWord:

    case QTextCursor::WordLeft:

        newPosition = priv->previousCursorPosition(position, QTextLayout::SkipWords);

        break;

    case QTextCursor::Up: {

        int i = line.lineNumber() - 1;

        if (i == -1) {

            if (blockIt == priv->blocksBegin())

                return false;

            int blockPosition = blockIt.position();

            QTextTable *table = qobject_cast<QTextTable *>(priv->frameAt(blockPosition));

            if (table) {

                QTextTableCell cell = table->cellAt(blockPosition);

                if (cell.firstPosition() == blockPosition) {

                    int row = cell.row() - 1;

                    if (row >= 0) {

                        blockPosition = table->cellAt(row, cell.column()).lastPosition();

                    } else {

                        // move to line above the table

                        blockPosition = table->firstPosition() - 1;

                    }

                    blockIt = priv->blocksFind(blockPosition);

                } else {

                    blockIt = blockIt.previous();

                }

            } else {

                blockIt = blockIt.previous();

            }

            layout = blockLayout(blockIt);

            i = layout->lineCount()-1;

        }

        if (layout->lineCount()) {

            QTextLine line = layout->lineAt(i);

            newPosition = line.xToCursor(x) + blockIt.position();

        } else {

            newPosition = blockIt.position();

        }

        adjustX = false;

        break;

    }

    case QTextCursor::End:

        newPosition = priv->length() - 1;

        break;

    case QTextCursor::EndOfLine: {

        if (!line.isValid() || line.textLength() == 0) {

            if (blockIt.length() >= 1)

                // position right before the block separator

                newPosition = blockIt.position() + blockIt.length() - 1;

            break;

        }

        newPosition = blockIt.position() + line.textStart() + line.textLength();

        if (line.lineNumber() < layout->lineCount() - 1) {

            const QString text = blockIt.text();

            // ###### this relies on spaces being the cause for linebreaks.

            // this doesn't work with japanese

            if (text.at(line.textStart() + line.textLength() - 1).isSpace())

                --newPosition;

        }

        break;

    }

    case QTextCursor::EndOfWord: {

        QTextEngine *engine = layout->engine();

        engine->attributes();

        const int len = blockIt.length() - 1;

        if (relativePos >= len)

            return false;

        if (engine->atWordSeparator(relativePos)) {

            ++relativePos;

            while (relativePos < len && engine->atWordSeparator(relativePos))

                ++relativePos;

        } else {

            while (relativePos < len && !engine->atSpace(relativePos) && !engine->atWordSeparator(relativePos))

                ++relativePos;

        }

        newPosition = blockIt.position() + relativePos;

        break;

    }

    case QTextCursor::EndOfBlock:

        if (blockIt.length() >= 1)

            // position right before the block separator

            newPosition = blockIt.position() + blockIt.length() - 1;

        break;

    case QTextCursor::NextBlock: {

        blockIt = blockIt.next();

        if (!blockIt.isValid())

            return false;

        newPosition = blockIt.position();

        break;

    }

    case QTextCursor::NextCharacter:

    case QTextCursor::Right:

        newPosition = priv->nextCursorPosition(position, QTextLayout::SkipCharacters);

        break;