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

**

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

#include "qtextcursor.h"

#include "qtextformat.h"

#include <qdebug.h>

#include "qtexttable_p.h"

#include "qvarlengtharray.h"

#include "private/qfunctions_p.h"

#include <stdlib.h>

QT_BEGIN_NAMESPACE

/*!

    \class QTextTableCell

    \reentrant

    \brief The QTextTableCell class represents the properties of a

    cell in a QTextTable.

    \ingroup richtext-processing

    Table cells are pieces of document structure that belong to a table.

    The table orders cells into particular rows and columns; cells can

    also span multiple columns and rows.

    Cells are usually created when a table is inserted into a document with

    QTextCursor::insertTable(), but they are also created and destroyed when

    a table is resized.

    Cells contain information about their location in a table; you can

    obtain the row() and column() numbers of a cell, and its rowSpan()

    and columnSpan().

    The format() of a cell describes the default character format of its

    contents. The firstCursorPosition() and lastCursorPosition() functions

    are used to obtain the extent of the cell in the document.

    \sa QTextTable QTextTableFormat

*/

/*!

    \fn QTextTableCell::QTextTableCell()

    Constructs an invalid table cell.

    \sa isValid()

*/

/*!

    \fn QTextTableCell::QTextTableCell(const QTextTableCell &other)

    Copy constructor. Creates a new QTextTableCell object based on the

    \a other cell.

*/

/*!

    \fn QTextTableCell& QTextTableCell::operator=(const QTextTableCell &other)

    Assigns the \a other table cell to this table cell.

*/

/*!

    \since 4.2

    Sets the cell's character format to \a format. This can for example be used to change

    the background color of the entire cell:

    QTextTableCell cell = table->cellAt(2, 3);

    QTextCharFormat format = cell.format();

    format.setBackground(Qt::blue);

    cell.setFormat(format);

    Note that the cell's row or column span cannot be changed through this function. You have

    to use QTextTable::mergeCells and QTextTable::splitCell instead.

    \sa format()

*/

void QTextTableCell::setFormat(const QTextCharFormat &format)

{

    QTextCharFormat fmt = format;

    fmt.clearProperty(QTextFormat::ObjectIndex);

    fmt.setObjectType(QTextFormat::TableCellObject);

    QTextDocumentPrivate *p = table->docHandle();

    QTextDocumentPrivate::FragmentIterator frag(&p->fragmentMap(), fragment);

    QTextFormatCollection *c = p->formatCollection();

    QTextCharFormat oldFormat = c->charFormat(frag->format);

    fmt.setTableCellRowSpan(oldFormat.tableCellRowSpan());

    fmt.setTableCellColumnSpan(oldFormat.tableCellColumnSpan());

    p->setCharFormat(frag.position(), 1, fmt, QTextDocumentPrivate::SetFormatAndPreserveObjectIndices);

}

/*!

    Returns the cell's character format.

*/

QTextCharFormat QTextTableCell::format() const

{

    QTextDocumentPrivate *p = table->docHandle();

    QTextFormatCollection *c = p->formatCollection();

    QTextCharFormat fmt = c->charFormat(tableCellFormatIndex());

    fmt.setObjectType(QTextFormat::TableCellObject);

    return fmt;

}

/*!

    \since 4.5

    Returns the index of the tableCell's format in the document's internal list of formats.

    \sa QTextDocument::allFormats()

*/

int QTextTableCell::tableCellFormatIndex() const

{

    QTextDocumentPrivate *p = table->docHandle();

    return QTextDocumentPrivate::FragmentIterator(&p->fragmentMap(), fragment)->format;

}

/*!

    Returns the number of the row in the table that contains this cell.

    \sa column()

*/

int QTextTableCell::row() const

{

    const QTextTablePrivate *tp = table->d_func();

    if (tp->dirty)

        tp->update();

    int idx = tp->findCellIndex(fragment);

    if (idx == -1)

        return idx;

    return tp->cellIndices.at(idx) / tp->nCols;

}

/*!

    Returns the number of the column in the table that contains this cell.

    \sa row()

*/

int QTextTableCell::column() const

{

    const QTextTablePrivate *tp = table->d_func();

    if (tp->dirty)

        tp->update();

    int idx = tp->findCellIndex(fragment);

    if (idx == -1)

        return idx;

    return tp->cellIndices.at(idx) % tp->nCols;

}

/*!

    Returns the number of rows this cell spans. The default is 1.

    \sa columnSpan()

*/

int QTextTableCell::rowSpan() const

{

    return format().tableCellRowSpan();

}

/*!

    Returns the number of columns this cell spans. The default is 1.

    \sa rowSpan()

*/

int QTextTableCell::columnSpan() const

{

    return format().tableCellColumnSpan();

}

/*!

    \fn bool QTextTableCell::isValid() const

    Returns true if this is a valid table cell; otherwise returns

    false.

*/

/*!

    Returns the first valid cursor position in this cell.

    \sa lastCursorPosition()

*/

QTextCursor QTextTableCell::firstCursorPosition() const

{

    return QTextCursor(table->d_func()->pieceTable, firstPosition());

}

/*!

    Returns the last valid cursor position in this cell.

    \sa firstCursorPosition()

*/

QTextCursor QTextTableCell::lastCursorPosition() const

{

    return QTextCursor(table->d_func()->pieceTable, lastPosition());

}

/*!

    \internal

    Returns the first valid position in the document occupied by this cell.

*/

int QTextTableCell::firstPosition() const

{

    QTextDocumentPrivate *p = table->docHandle();

    return p->fragmentMap().position(fragment) + 1;

}

/*!

    \internal

    Returns the last valid position in the document occupied by this cell.

*/

int QTextTableCell::lastPosition() const

{

    QTextDocumentPrivate *p = table->docHandle();

    const QTextTablePrivate *td = table->d_func();

    int index = table->d_func()->findCellIndex(fragment);

    int f;

    if (index != -1)

        f = td->cells.value(index + 1, td->fragment_end);

    else

        f = td->fragment_end;

    return p->fragmentMap().position(f);

}

/*!

    Returns a frame iterator pointing to the beginning of the table's cell.

    \sa end()

*/

QTextFrame::iterator QTextTableCell::begin() const

{

    QTextDocumentPrivate *p = table->docHandle();

    int b = p->blockMap().findNode(firstPosition());

    int e = p->blockMap().findNode(lastPosition()+1);

    return QTextFrame::iterator(const_cast<QTextTable *>(table), b, b, e);

}

/*!

    Returns a frame iterator pointing to the end of the table's cell.

    \sa begin()

*/

QTextFrame::iterator QTextTableCell::end() const

{

    QTextDocumentPrivate *p = table->docHandle();

    int b = p->blockMap().findNode(firstPosition());

    int e = p->blockMap().findNode(lastPosition()+1);

    return QTextFrame::iterator(const_cast<QTextTable *>(table), e, b, e);

}

/*!

    \fn QTextCursor QTextTableCell::operator==(const QTextTableCell &other) const

    Returns true if this cell object and the \a other cell object

    describe the same cell; otherwise returns false.

*/

/*!

    \fn QTextCursor QTextTableCell::operator!=(const QTextTableCell &other) const

    Returns true if this cell object and the \a other cell object

    describe different cells; otherwise returns false.

*/

/*!

    \fn QTextTableCell::~QTextTableCell()

    Destroys the table cell.

*/

QTextTablePrivate::~QTextTablePrivate()

{

    if (grid)

        free(grid);

}

QTextTable *QTextTablePrivate::createTable(QTextDocumentPrivate *pieceTable, int pos, int rows, int cols, const QTextTableFormat &tableFormat)

{

    QTextTableFormat fmt = tableFormat;

    fmt.setColumns(cols);

    QTextTable *table = qobject_cast<QTextTable *>(pieceTable->createObject(fmt));

    Q_ASSERT(table);

    pieceTable->beginEditBlock();

//     qDebug("---> createTable: rows=%d, cols=%d at %d", rows, cols, pos);

    // add block after table

    QTextCharFormat charFmt;

    charFmt.setObjectIndex(table->objectIndex());

    charFmt.setObjectType(QTextFormat::TableCellObject);

    int charIdx = pieceTable->formatCollection()->indexForFormat(charFmt);

    int cellIdx = pieceTable->formatCollection()->indexForFormat(QTextBlockFormat());

    QTextTablePrivate *d = table->d_func();

    d->blockFragmentUpdates = true;

    d->fragment_start = pieceTable->insertBlock(QTextBeginningOfFrame, pos, cellIdx, charIdx);

    d->cells.append(d->fragment_start);

    ++pos;

    for (int i = 1; i < rows*cols; ++i) {

        d->cells.append(pieceTable->insertBlock(QTextBeginningOfFrame, pos, cellIdx, charIdx));

// 	    qDebug("      addCell at %d", pos);

        ++pos;

    }

    d->fragment_end = pieceTable->insertBlock(QTextEndOfFrame, pos, cellIdx, charIdx);

// 	qDebug("      addEOR at %d", pos);

    ++pos;

    d->blockFragmentUpdates = false;

    d->dirty = true;

    pieceTable->endEditBlock();

    return table;

}

struct QFragmentFindHelper

{

    inline QFragmentFindHelper(int _pos, const QTextDocumentPrivate::FragmentMap &map)

        : pos(_pos), fragmentMap(map) {}

    uint pos;

    const QTextDocumentPrivate::FragmentMap &fragmentMap;

};

Q_STATIC_GLOBAL_INLINE_OPERATOR bool operator<(int fragment, const QFragmentFindHelper &helper)

{

    return helper.fragmentMap.position(fragment) < helper.pos;

}

Q_STATIC_GLOBAL_INLINE_OPERATOR bool operator<(const QFragmentFindHelper &helper, int fragment)

{

    return helper.pos < helper.fragmentMap.position(fragment);

}

int QTextTablePrivate::findCellIndex(int fragment) const

{

    QFragmentFindHelper helper(pieceTable->fragmentMap().position(fragment),

                              pieceTable->fragmentMap());

    QList<int>::ConstIterator it = qBinaryFind(cells.begin(), cells.end(), helper);

    if (it == cells.end())

        return -1;

    return it - cells.begin();

}

void QTextTablePrivate::fragmentAdded(const QChar &type, uint fragment)

{

    dirty = true;

    if (blockFragmentUpdates)

        return;

    if (type == QTextBeginningOfFrame) {

        Q_ASSERT(cells.indexOf(fragment) == -1);

        const uint pos = pieceTable->fragmentMap().position(fragment);

        QFragmentFindHelper helper(pos, pieceTable->fragmentMap());

        QList<int>::Iterator it = qLowerBound(cells.begin(), cells.end(), helper);

        cells.insert(it, fragment);

        if (!fragment_start || pos < pieceTable->fragmentMap().position(fragment_start))

            fragment_start = fragment;

        return;

    }

    QTextFramePrivate::fragmentAdded(type, fragment);

}

void QTextTablePrivate::fragmentRemoved(const QChar &type, uint fragment)

{

    dirty = true;

    if (blockFragmentUpdates)

        return;

    if (type == QTextBeginningOfFrame) {

        Q_ASSERT(cells.indexOf(fragment) != -1);

        cells.removeAll(fragment);

        if (fragment_start == fragment && cells.size()) {

            fragment_start = cells.at(0);

        }

        if (fragment_start != fragment)

            return;

    }

    QTextFramePrivate::fragmentRemoved(type, fragment);

}

/*!

    /fn void QTextTablePrivate::update() const

    This function is usually called when the table is "dirty".

    It seems to update all kind of table information.

*/

void QTextTablePrivate::update() const

{

    Q_Q(const QTextTable);

    nCols = q->format().columns();

    nRows = (cells.size() + nCols-1)/nCols;

//     qDebug(">>>> QTextTablePrivate::update, nRows=%d, nCols=%d", nRows, nCols);

    grid = q_check_ptr((int *)realloc(grid, nRows*nCols*sizeof(int)));

    memset(grid, 0, nRows*nCols*sizeof(int));

    QTextDocumentPrivate *p = pieceTable;

    QTextFormatCollection *c = p->formatCollection();

    cellIndices.resize(cells.size());

    int cell = 0;

    for (int i = 0; i < cells.size(); ++i) {

        int fragment = cells.at(i);

        QTextCharFormat fmt = c->charFormat(QTextDocumentPrivate::FragmentIterator(&p->fragmentMap(), fragment)->format);

        int rowspan = fmt.tableCellRowSpan();

        int colspan = fmt.tableCellColumnSpan();

        // skip taken cells

        while (cell < nRows*nCols && grid[cell])

            ++cell;

        int r = cell/nCols;

        int c = cell%nCols;

        cellIndices[i] = cell;

        if (r + rowspan > nRows) {

            grid = q_check_ptr((int *)realloc(grid, sizeof(int)*(r + rowspan)*nCols));

            memset(grid + (nRows*nCols), 0, sizeof(int)*(r+rowspan-nRows)*nCols);

            nRows = r + rowspan;

        }

        Q_ASSERT(c + colspan <= nCols);

        for (int ii = 0; ii < rowspan; ++ii) {

            for (int jj = 0; jj < colspan; ++jj) {

                Q_ASSERT(grid[(r+ii)*nCols + c+jj] == 0);

                grid[(r+ii)*nCols + c+jj] = fragment;

//  		    qDebug("    setting cell %d span=%d/%d at %d/%d", fragment, rowspan, colspan, r+ii, c+jj);

            }

        }

    }

//     qDebug("<<<< end: nRows=%d, nCols=%d", nRows, nCols);

    dirty = false;

}

/*!

    \class QTextTable

    \reentrant

    \brief The QTextTable class represents a table in a QTextDocument.

    \ingroup richtext-processing

    A table is a group of cells ordered into rows and columns. Each table

    contains at least one row and one column. Each cell contains a block, and

    is surrounded by a frame.

    Tables are usually created and inserted into a document with the

    QTextCursor::insertTable() function.

    For example, we can insert a table with three rows and two columns at the

    current cursor position in an editor using the following lines of code:

    \snippet doc/src/snippets/textdocument-tables/mainwindow.cpp 1

    \codeline

    \snippet doc/src/snippets/textdocument-tables/mainwindow.cpp 3

    The table format is either defined when the table is created or changed

    later with setFormat().

    The table currently being edited by the cursor is found with

    QTextCursor::currentTable(). This allows its format or dimensions to be

    changed after it has been inserted into a document.

    A table's size can be changed with resize(), or by using

    insertRows(), insertColumns(), removeRows(), or removeColumns().

    Use cellAt() to retrieve table cells.

    The starting and ending positions of table rows can be found by moving