1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qtextcursor.h"

    43 #include "qtextcursor_p.h"

    44 #include "qglobal.h"

    45 #include "qtextdocumentfragment.h"

    46 #include "qtextdocumentfragment_p.h"

    47 #include "qtextlist.h"

    48 #include "qtexttable.h"

    49 #include "qtexttable_p.h"

    50 #include "qtextengine_p.h"

    51 #include "qabstracttextdocumentlayout.h"

    52 

    53 #include <qtextlayout.h>

    54 #include <qdebug.h>

    55 

    56 QT_BEGIN_NAMESPACE

    57 

    58 enum {

    59     AdjustPrev = 0x1,

    60     AdjustUp = 0x3,

    61     AdjustNext = 0x4,

    62     AdjustDown = 0x12

    63 };

    64 

    65 QTextCursorPrivate::QTextCursorPrivate(QTextDocumentPrivate *p)

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

    67       currentCharFormat(-1), visualNavigation(false)

    68 {

    69     priv->addCursor(this);

    70 }

    71 

    72 QTextCursorPrivate::QTextCursorPrivate(const QTextCursorPrivate &rhs)

    73     : QSharedData(rhs)

    74 {

    75     position = rhs.position;

    76     anchor = rhs.anchor;

    77     adjusted_anchor = rhs.adjusted_anchor;

    78     priv = rhs.priv;

    79     x = rhs.x;

    80     currentCharFormat = rhs.currentCharFormat;

    81     visualNavigation = rhs.visualNavigation;

    82     priv->addCursor(this);

    83 }

    84 

    85 QTextCursorPrivate::~QTextCursorPrivate()

    86 {

    87     if (priv)

    88         priv->removeCursor(this);

    89 }

    90 

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

    92 {

    93     QTextCursorPrivate::AdjustResult result = QTextCursorPrivate::CursorMoved;

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

    95     if (position < positionOfChange

    96         || (position == positionOfChange

    97             && (op == QTextUndoCommand::KeepCursor

    98                 || anchor < position)

    99             )

   100          ) {

   101         result = CursorUnchanged;

   102     } else {

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

   104             position = positionOfChange;

   105         else

   106             position += charsAddedOrRemoved;

   107 

   108         currentCharFormat = -1;

   109     }

   110 

   111     if (anchor >= positionOfChange

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

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

   114             anchor = positionOfChange;

   115         else

   116             anchor += charsAddedOrRemoved;

   117     }

   118 

   119     if (adjusted_anchor >= positionOfChange

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

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

   122             adjusted_anchor = positionOfChange;

   123         else

   124             adjusted_anchor += charsAddedOrRemoved;

   125     }

   126 

   127     return result;

   128 }

   129 

   130 void QTextCursorPrivate::setX()

   131 {

   132     if (priv->isInEditBlock()) {

   133         x = -1; // mark dirty

   134         return;

   135     }

   136 

   137     QTextBlock block = this->block();

   138     const QTextLayout *layout = blockLayout(block);

   139     int pos = position - block.position();

   140 

   141     QTextLine line = layout->lineForTextPosition(pos);

   142     if (line.isValid())

   143         x = line.cursorToX(pos);

   144     else

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

   146 }

   147 

   148 void QTextCursorPrivate::remove()

   149 {

   150     if (anchor == position)

   151         return;

   152     currentCharFormat = -1;

   153     int pos1 = position;

   154     int pos2 = adjusted_anchor;

   155     QTextUndoCommand::Operation op = QTextUndoCommand::KeepCursor;

   156     if (pos1 > pos2) {

   157         pos1 = adjusted_anchor;

   158         pos2 = position;

   159         op = QTextUndoCommand::MoveCursor;

   160     }

   161 

   162     // deleting inside table? -> delete only content

   163     QTextTable *table = complexSelectionTable();

   164     if (table) {

   165         priv->beginEditBlock();

   166         int startRow, startCol, numRows, numCols;

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

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

   169         adjusted_anchor = anchor = position;

   170         priv->endEditBlock();

   171     } else {

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

   173         adjusted_anchor = anchor = position;

   174         priv->finishEdit();

   175     }

   176 

   177 }

   178 

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

   180 {

   181     priv->beginEditBlock();

   182 

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

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

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

   186             const int startPos = cell.firstPosition();

   187             const int endPos = cell.lastPosition();

   188             Q_ASSERT(startPos <= endPos);

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

   190         }

   191 

   192     priv->endEditBlock();

   193 }

   194 

   195 bool QTextCursorPrivate::canDelete(int pos) const

   196 {

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

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

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

   200 }

   201 

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

   203 {

   204     QTextFormatCollection *formats = priv->formatCollection();

   205     int idx = formats->indexForFormat(format);

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

   207 

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

   209     currentCharFormat = -1;

   210 }

   211 

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

   213 {

   214     adjusted_anchor = anchor;

   215     if (position == anchor)

   216         return;

   217 

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

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

   220 

   221     if (f_position != f_anchor) {

   222         // find common parent frame

   223         QList<QTextFrame *> positionChain;

   224         QList<QTextFrame *> anchorChain;

   225         QTextFrame *f = f_position;

   226         while (f) {

   227             positionChain.prepend(f);

   228             f = f->parentFrame();

   229         }

   230         f = f_anchor;

   231         while (f) {

   232             anchorChain.prepend(f);

   233             f = f->parentFrame();

   234         }

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

   236         int i = 1;

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

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

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

   240                 break;

   241         }

   242 

   243         if (m <= QTextCursor::WordLeft) {

   244             if (i < positionChain.size())

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

   246         } else {

   247             if (i < positionChain.size())

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

   249         }

   250         if (position < adjusted_anchor) {

   251             if (i < anchorChain.size())

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

   253         } else {

   254             if (i < anchorChain.size())

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

   256         }

   257 

   258         f_position = positionChain.at(i-1);

   259     }

   260 

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

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

   263     if (!table)

   264         return;

   265 

   266     QTextTableCell c_position = table->cellAt(position);

   267     QTextTableCell c_anchor = table->cellAt(adjusted_anchor);

   268     if (c_position != c_anchor) {

   269         bool before;

   270         int col_position = c_position.column();

   271         int col_anchor = c_anchor.column();

   272         if (col_position == col_anchor) {

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

   274         } else {

   275             before = col_position < col_anchor;

   276         }

   277 

   278         // adjust to cell boundaries

   279         if (m <= QTextCursor::WordLeft) {

   280             position = c_position.firstPosition();

   281             if (!before)

   282                 --position;

   283         } else {

   284             position = c_position.lastPosition();

   285             if (before)

   286                 ++position;

   287         }

   288         if (position < adjusted_anchor)

   289             adjusted_anchor = c_anchor.lastPosition();

   290         else

   291             adjusted_anchor = c_anchor.firstPosition();

   292     }

   293     currentCharFormat = -1;

   294 }

   295 

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

   297 {

   298     Q_ASSERT(from <= to);

   299     if (position == anchor)

   300         return;

   301 

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

   303     if (!t)

   304         return;

   305     QTextTableCell removedCellFrom = t->cellAt(from);

   306     QTextTableCell removedCellEnd = t->cellAt(to);

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

   308         return;

   309 

   310     int curFrom = position;

   311     int curTo = adjusted_anchor;

   312     if (curTo < curFrom)

   313         qSwap(curFrom, curTo);

   314 

   315     QTextTableCell cellStart = t->cellAt(curFrom);

   316     QTextTableCell cellEnd = t->cellAt(curTo);

   317 

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

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

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

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

   322         QTextTableCell cell;

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

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

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

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

   327 

   328         int newPosition;

   329         if (cell.isValid())

   330             newPosition = cell.firstPosition();

   331         else

   332             newPosition = t->lastPosition()+1;

   333 

   334         setPosition(newPosition);

   335         anchor = newPosition;

   336         adjusted_anchor = newPosition;

   337         x = 0;

   338     }

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

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

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

   342         if (position < anchor)

   343             position = newPosition;

   344         else

   345             anchor = adjusted_anchor = newPosition;

   346     }

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

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

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

   350         if (position < anchor)

   351             position = newPosition;

   352         else

   353             anchor = adjusted_anchor = newPosition;

   354     }

   355 }

   356 

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

   358 {

   359     currentCharFormat = -1;

   360     bool adjustX = true;

   361     QTextBlock blockIt = block();

   362 

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

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

   365         if (op == QTextCursor::Left)

   366             op = QTextCursor::NextCharacter;

   367         else if (op == QTextCursor::Right)

   368             op = QTextCursor::PreviousCharacter;

   369         else if (op == QTextCursor::WordLeft)

   370             op = QTextCursor::NextWord;

   371         else if (op == QTextCursor::WordRight)

   372             op = QTextCursor::PreviousWord;

   373     }

   374 

   375     const QTextLayout *layout = blockLayout(blockIt);

   376     int relativePos = position - blockIt.position();

   377     QTextLine line;

   378     if (!priv->isInEditBlock())

   379         line = layout->lineForTextPosition(relativePos);

   380 

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

   382 

   383     int newPosition = position;

   384 

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

   386         setX();

   387 

   388     switch(op) {

   389     case QTextCursor::NoMove:

   390         return true;

   391 

   392     case QTextCursor::Start:

   393         newPosition = 0;

   394         break;

   395     case QTextCursor::StartOfLine: {

   396         newPosition = blockIt.position();

   397         if (line.isValid())

   398             newPosition += line.textStart();

   399 

   400         break;

   401     }

   402     case QTextCursor::StartOfBlock: {

   403         newPosition = blockIt.position();

   404         break;

   405     }

   406     case QTextCursor::PreviousBlock: {

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

   408             return false;

   409         blockIt = blockIt.previous();

   410 

   411         newPosition = blockIt.position();

   412         break;

   413     }

   414     case QTextCursor::PreviousCharacter:

   415     case QTextCursor::Left:

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

   417         break;

   418     case QTextCursor::StartOfWord: {

   419         if (relativePos == 0)

   420             break;

   421 

   422         // skip if already at word start

   423         QTextEngine *engine = layout->engine();

   424         engine->attributes();

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

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

   427             return false;

   428 

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

   430             ++position;

   431 

   432         // FALL THROUGH!

   433     }

   434     case QTextCursor::PreviousWord:

   435     case QTextCursor::WordLeft:

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

   437         break;

   438     case QTextCursor::Up: {

   439         int i = line.lineNumber() - 1;

   440         if (i == -1) {

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

   442                 return false;

   443             int blockPosition = blockIt.position();

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

   445             if (table) {

   446                 QTextTableCell cell = table->cellAt(blockPosition);

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

   448                     int row = cell.row() - 1;

   449                     if (row >= 0) {

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

   451                     } else {

   452                         // move to line above the table

   453                         blockPosition = table->firstPosition() - 1;

   454                     }

   455                     blockIt = priv->blocksFind(blockPosition);

   456                 } else {

   457                     blockIt = blockIt.previous();

   458                 }

   459             } else {

   460                 blockIt = blockIt.previous();

   461             }

   462             layout = blockLayout(blockIt);

   463             i = layout->lineCount()-1;

   464         }

   465         if (layout->lineCount()) {

   466             QTextLine line = layout->lineAt(i);

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

   468         } else {

   469             newPosition = blockIt.position();

   470         }

   471         adjustX = false;

   472         break;

   473     }

   474 

   475     case QTextCursor::End:

   476         newPosition = priv->length() - 1;

   477         break;

   478     case QTextCursor::EndOfLine: {

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

   480             if (blockIt.length() >= 1)

   481                 // position right before the block separator

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

   483             break;

   484         }

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

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

   487             const QString text = blockIt.text();

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

   489             // this doesn't work with japanese

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

   491                 --newPosition;

   492         }

   493         break;

   494     }

   495     case QTextCursor::EndOfWord: {

   496         QTextEngine *engine = layout->engine();

   497         engine->attributes();

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

   499         if (relativePos >= len)

   500             return false;

   501         if (engine->atWordSeparator(relativePos)) {

   502             ++relativePos;

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

   504                 ++relativePos;

   505         } else {

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

   507                 ++relativePos;

   508         }

   509         newPosition = blockIt.position() + relativePos;

   510         break;

   511     }

   512     case QTextCursor::EndOfBlock:

   513         if (blockIt.length() >= 1)

   514             // position right before the block separator

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

   516         break;

   517     case QTextCursor::NextBlock: {

   518         blockIt = blockIt.next();

   519         if (!blockIt.isValid())

   520             return false;

   521 

   522         newPosition = blockIt.position();

   523         break;

   524     }

   525     case QTextCursor::NextCharacter:

   526     case QTextCursor::Right:

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

   528         break;

   529     case QTextCursor::NextWord:

   530     case QTextCursor::WordRight:

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

   532         break;

   533 

   534     case QTextCursor::Down: {

   535         int i = line.lineNumber() + 1;

   536 

   537         if (i >= layout->lineCount()) {

   538             int blockPosition = blockIt.position() + blockIt.length() - 1;

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

   540             if (table) {

   541                 QTextTableCell cell = table->cellAt(blockPosition);

   542                 if (cell.lastPosition() == blockPosition) {

   543                     int row = cell.row() + cell.rowSpan();

   544                     if (row < table->rows()) {

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

   546                     } else {

   547                         // move to line below the table

   548                         blockPosition = table->lastPosition() + 1;

   549                     }

   550                     blockIt = priv->blocksFind(blockPosition);

   551                 } else {

   552                     blockIt = blockIt.next();

   553                 }

   554             } else {

   555                 blockIt = blockIt.next();

   556             }

   557 

   558             if (blockIt == priv->blocksEnd())

   559                 return false;

   560             layout = blockLayout(blockIt);

   561             i = 0;

   562         }

   563         if (layout->lineCount()) {

   564             QTextLine line = layout->lineAt(i);

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

   566         } else {

   567             newPosition = blockIt.position();

   568         }

   569         adjustX = false;

   570         break;

   571     }

   572     case QTextCursor::NextCell: // fall through

   573     case QTextCursor::PreviousCell: // fall through

   574     case QTextCursor::NextRow: // fall through

   575     case QTextCursor::PreviousRow: {

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

   577         if (!table)

   578             return false;

   579 

   580         QTextTableCell cell = table->cellAt(position);

   581         Q_ASSERT(cell.isValid());

   582         int column = cell.column();

   583         int row = cell.row();

   584         const int currentRow = row;

   585         if (op == QTextCursor::NextCell || op == QTextCursor::NextRow) {

   586             do {

   587                 column += cell.columnSpan();

   588                 if (column >= table->columns()) {

   589                     column = 0;

   590                     ++row;

   591                 }

   592                 cell = table->cellAt(row, column);

   593                 // note we also continue while we have not reached a cell thats not merged with one above us

   594             } while (cell.isValid()

   595                     && ((op == QTextCursor::NextRow && currentRow == cell.row())

   596                         || cell.row() < row));

   597         }

   598         else if (op == QTextCursor::PreviousCell || op == QTextCursor::PreviousRow) {

   599             do {

   600                 --column;

   601                 if (column < 0) {

   602                     column = table->columns()-1;

   603                     --row;

   604                 }

   605                 cell = table->cellAt(row, column);

   606                 // note we also continue while we have not reached a cell thats not merged with one above us

   607             } while (cell.isValid()

   608                     && ((op == QTextCursor::PreviousRow && currentRow == cell.row())

   609                         || cell.row() < row));

   610         }

   611         if (cell.isValid())

   612             newPosition = cell.firstPosition();

   613         break;

   614     }

   615     }

   616 

   617     if (mode == QTextCursor::KeepAnchor) {

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

   619         if (table && ((op >= QTextCursor::PreviousBlock && op <= QTextCursor::WordLeft)

   620                       || (op >= QTextCursor::NextBlock && op <= QTextCursor::WordRight))) {

   621             int oldColumn = table->cellAt(position).column();

   622 

   623             const QTextTableCell otherCell = table->cellAt(newPosition);

   624             if (!otherCell.isValid())

   625                 return false;

   626 

   627             int newColumn = otherCell.column();

   628             if ((oldColumn > newColumn && op >= QTextCursor::End)

   629                 || (oldColumn < newColumn && op <= QTextCursor::WordLeft))

   630                 return false;

   631         }

   632     }

   633 

   634     const bool moved = setPosition(newPosition);

   635 

   636     if (mode == QTextCursor::MoveAnchor) {

   637         anchor = position;

   638         adjusted_anchor = position;

   639     } else {

   640         adjustCursor(op);

   641     }

   642 

   643     if (adjustX)

   644         setX();

   645 

   646     return moved;

   647 }

   648 

   649 QTextTable *QTextCursorPrivate::complexSelectionTable() const

   650 {

   651     if (position == anchor)

   652         return 0;

   653 

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

   655     if (t) {

   656         QTextTableCell cell_pos = t->cellAt(position);

   657         QTextTableCell cell_anchor = t->cellAt(adjusted_anchor);

   658 

   659         Q_ASSERT(cell_anchor.isValid());

   660 

   661         if (cell_pos == cell_anchor)

   662             t = 0;

   663     }

   664     return t;

   665 }

   666 

   667 void QTextCursorPrivate::selectedTableCells(int *firstRow, int *numRows, int *firstColumn, int *numColumns) const

   668 {

   669     *firstRow = -1;

   670     *firstColumn = -1;

   671     *numRows = -1;

   672     *numColumns = -1;

   673 

   674     if (position == anchor)

   675         return;

   676 

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

   678     if (!t)

   679         return;

   680 

   681     QTextTableCell cell_pos = t->cellAt(position);

   682     QTextTableCell cell_anchor = t->cellAt(adjusted_anchor);

   683 

   684     Q_ASSERT(cell_anchor.isValid());

   685 

   686     if (cell_pos == cell_anchor)

   687         return;

   688 

   689     *firstRow = qMin(cell_pos.row(), cell_anchor.row());

   690     *firstColumn = qMin(cell_pos.column(), cell_anchor.column());

   691     *numRows = qMax(cell_pos.row() + cell_pos.rowSpan(), cell_anchor.row() + cell_anchor.rowSpan()) - *firstRow;

   692     *numColumns = qMax(cell_pos.column() + cell_pos.columnSpan(), cell_anchor.column() + cell_anchor.columnSpan()) - *firstColumn;

   693 }

   694 

   695 static void setBlockCharFormatHelper(QTextDocumentPrivate *priv, int pos1, int pos2,

   696                                const QTextCharFormat &format, QTextDocumentPrivate::FormatChangeMode changeMode)

   697 {

   698     QTextBlock it = priv->blocksFind(pos1);

   699     QTextBlock end = priv->blocksFind(pos2);

   700     if (end.isValid())

   701         end = end.next();

   702 

   703     for (; it != end; it = it.next()) {

   704         priv->setCharFormat(it.position() - 1, 1, format, changeMode);

   705     }

   706 }

   707 

   708 void QTextCursorPrivate::setBlockCharFormat(const QTextCharFormat &_format,

   709     QTextDocumentPrivate::FormatChangeMode changeMode)

   710 {

   711     priv->beginEditBlock();

   712 

   713     QTextCharFormat format = _format;

   714     format.clearProperty(QTextFormat::ObjectIndex);

   715 

   716     QTextTable *table = complexSelectionTable();

   717     if (table) {

   718         int row_start, col_start, num_rows, num_cols;

   719         selectedTableCells(&row_start, &num_rows, &col_start, &num_cols);

   720 

   721         Q_ASSERT(row_start != -1);

   722         for (int r = row_start; r < row_start + num_rows; ++r) {

   723             for (int c = col_start; c < col_start + num_cols; ++c) {

   724                 QTextTableCell cell = table->cellAt(r, c);

   725                 int rspan = cell.rowSpan();

   726                 int cspan = cell.columnSpan();

   727                 if (rspan != 1) {

   728                     int cr = cell.row();

   729                     if (cr != r)

   730                         continue;

   731                 }

   732                 if (cspan != 1) {

   733                     int cc = cell.column();

   734                     if (cc != c)

   735                         continue;

   736                 }

   737 

   738                 int pos1 = cell.firstPosition();

   739                 int pos2 = cell.lastPosition();

   740                 setBlockCharFormatHelper(priv, pos1, pos2, format, changeMode);

   741             }

   742         }

   743     } else {

   744         int pos1 = position;

   745         int pos2 = adjusted_anchor;

   746         if (pos1 > pos2) {

   747             pos1 = adjusted_anchor;

   748             pos2 = position;

   749         }

   750 

   751         setBlockCharFormatHelper(priv, pos1, pos2, format, changeMode);

   752     }

   753     priv->endEditBlock();

   754 }

   755 

   756 

   757 void QTextCursorPrivate::setBlockFormat(const QTextBlockFormat &format, QTextDocumentPrivate::FormatChangeMode changeMode)

   758 {

   759     QTextTable *table = complexSelectionTable();

   760     if (table) {

   761         priv->beginEditBlock();

   762         int row_start, col_start, num_rows, num_cols;

   763         selectedTableCells(&row_start, &num_rows, &col_start, &num_cols);

   764 

   765         Q_ASSERT(row_start != -1);

   766         for (int r = row_start; r < row_start + num_rows; ++r) {

   767             for (int c = col_start; c < col_start + num_cols; ++c) {

   768                 QTextTableCell cell = table->cellAt(r, c);

   769                 int rspan = cell.rowSpan();

   770                 int cspan = cell.columnSpan();

   771                 if (rspan != 1) {

   772                     int cr = cell.row();

   773                     if (cr != r)

   774                         continue;

   775                 }

   776                 if (cspan != 1) {

   777                     int cc = cell.column();

   778                     if (cc != c)

   779                         continue;

   780                 }

   781 

   782                 int pos1 = cell.firstPosition();

   783                 int pos2 = cell.lastPosition();

   784                 priv->setBlockFormat(priv->blocksFind(pos1), priv->blocksFind(pos2), format, changeMode);

   785             }

   786         }

   787         priv->endEditBlock();

   788     } else {

   789         int pos1 = position;

   790         int pos2 = adjusted_anchor;

   791         if (pos1 > pos2) {

   792             pos1 = adjusted_anchor;

   793             pos2 = position;

   794         }

   795 

   796         priv->setBlockFormat(priv->blocksFind(pos1), priv->blocksFind(pos2), format, changeMode);

   797     }

   798 }

   799 

   800 void QTextCursorPrivate::setCharFormat(const QTextCharFormat &_format, QTextDocumentPrivate::FormatChangeMode changeMode)

   801 {

   802     Q_ASSERT(position != anchor);

   803 

   804     QTextCharFormat format = _format;

   805     format.clearProperty(QTextFormat::ObjectIndex);

   806 

   807     QTextTable *table = complexSelectionTable();

   808     if (table) {

   809         priv->beginEditBlock();

   810         int row_start, col_start, num_rows, num_cols;

   811         selectedTableCells(&row_start, &num_rows, &col_start, &num_cols);

   812 

   813         Q_ASSERT(row_start != -1);

   814         for (int r = row_start; r < row_start + num_rows; ++r) {

   815             for (int c = col_start; c < col_start + num_cols; ++c) {

   816                 QTextTableCell cell = table->cellAt(r, c);

   817                 int rspan = cell.rowSpan();

   818                 int cspan = cell.columnSpan();

   819                 if (rspan != 1) {

   820                     int cr = cell.row();

   821                     if (cr != r)

   822                         continue;

   823                 }

   824                 if (cspan != 1) {

   825                     int cc = cell.column();

   826                     if (cc != c)

   827                         continue;

   828                 }

   829 

   830                 int pos1 = cell.firstPosition();

   831                 int pos2 = cell.lastPosition();

   832                 priv->setCharFormat(pos1, pos2-pos1, format, changeMode);

   833             }

   834         }

   835         priv->endEditBlock();

   836     } else {

   837         int pos1 = position;

   838         int pos2 = adjusted_anchor;

   839         if (pos1 > pos2) {

   840             pos1 = adjusted_anchor;

   841             pos2 = position;

   842         }

   843 

   844         priv->setCharFormat(pos1, pos2-pos1, format, changeMode);

   845     }

   846 }

   847 

   848 

   849 QTextLayout *QTextCursorPrivate::blockLayout(QTextBlock &block) const{

   850     QTextLayout *tl = block.layout();

   851     if (!tl->lineCount() && priv->layout())

   852         priv->layout()->blockBoundingRect(block);

   853     return tl;

   854 }

   855 

   856 /*!

   857     \class QTextCursor

   858     \reentrant

   859 

   860     \brief The QTextCursor class offers an API to access and modify QTextDocuments.

   861 

   862     \ingroup richtext-processing

   863     \ingroup shared

   864 

   865 

   866     Text cursors are objects that are used to access and modify the contents

   867     and underlying structure of text documents via a programming interface

   868     that mimics the behavior of a cursor in a text editor. QTextCursor contains

   869     information about both the cursor's position within a QTextDocument and any

   870     selection that it has made.

   871 

   872     QTextCursor is modeled on the way a text cursor behaves in a text

   873     editor, providing a programmatic means of performing standard actions

   874     through the user interface. A document can be thought of as a

   875     single string of characters with the cursor's position() being \e

   876     between any two characters (or at the very beginning or very end

   877     of the document). Documents can also contain tables, lists,

   878     images, and other objects in addition to text but, from the developer's

   879     point of view, the document can be treated as one long string.

   880     Some portions of that string can be considered to lie within particular

   881     blocks (e.g. paragraphs), or within a table's cell, or a list's item,

   882     or other structural elements. When we refer to "current character" we

   883     mean the character immediately after the cursor position() in the

   884     document; similarly the "current block" is the block that contains the

   885     cursor position().

   886 

   887     A QTextCursor also has an anchor() position. The text that is

   888     between the anchor() and the position() is the selection. If

   889     anchor() == position() there is no selection.

   890 

   891     The cursor position can be changed programmatically using

   892     setPosition() and movePosition(); the latter can also be used to

   893     select text. For selections see selectionStart(), selectionEnd(),

   894     hasSelection(), clearSelection(), and removeSelectedText().

   895 

   896     If the position() is at the start of a block atBlockStart()

   897     returns true; and if it is at the end of a block atBlockEnd() returns

   898     true. The format of the current character is returned by

   899     charFormat(), and the format of the current block is returned by

   900     blockFormat().

   901 

   902     Formatting can be applied to the current text document using the

   903     setCharFormat(), mergeCharFormat(), setBlockFormat() and

   904     mergeBlockFormat() functions. The 'set' functions will replace the

   905     cursor's current character or block format, while the 'merge'

   906     functions add the given format properties to the cursor's current

   907     format. If the cursor has a selection the given format is applied

   908     to the current selection. Note that when only parts of a block is

   909     selected the block format is applied to the entire block. The text

   910     at the current character position can be turned into a list using

   911     createList().

   912 

   913     Deletions can be achieved using deleteChar(),

   914     deletePreviousChar(), and removeSelectedText().

   915 

   916     Text strings can be inserted into the document with the insertText()

   917     function, blocks (representing new paragraphs) can be inserted with

   918     insertBlock().

   919 

   920     Existing fragments of text can be inserted with insertFragment() but,

   921     if you want to insert pieces of text in various formats, it is usually

   922     still easier to use insertText() and supply a character format.

   923 

   924     Various types of higher-level structure can also be inserted into the

   925     document with the cursor:

   926 

   927     \list

   928     \i Lists are ordered sequences of block elements that are decorated with

   929        bullet points or symbols. These are inserted in a specified format

   930        with insertList().

   931     \i Tables are inserted with the insertTable() function, and can be

   932        given an optional format. These contain an array of cells that can

   933        be traversed using the cursor.

   934     \i Inline images are inserted with insertImage(). The image to be

   935        used can be specified in an image format, or by name.

   936     \i Frames are inserted by calling insertFrame() with a specified format.

   937     \endlist

   938 

   939     Actions can be grouped (i.e. treated as a single action for

   940     undo/redo) using beginEditBlock() and endEditBlock().

   941 

   942     Cursor movements are limited to valid cursor positions. In Latin

   943     writing this is usually after every character in the text. In some

   944     other writing systems cursor movements are limited to "clusters"

   945     (e.g. a syllable in Devanagari, or a base letter plus diacritics).

   946     Functions such as movePosition() and deleteChar() limit cursor

   947     movement to these valid positions.

   948 

   949     \sa \link richtext.html Rich Text Processing\endlink

   950 

   951 */

   952 

   953 /*!

   954     \enum QTextCursor::MoveOperation

   955 

   956     \value NoMove Keep the cursor where it is

   957 

   958     \value Start Move to the start of the document.

   959     \value StartOfLine Move to the start of the current line.

   960     \value StartOfBlock Move to the start of the current block.

   961     \value StartOfWord Move to the start of the current word.

   962     \value PreviousBlock Move to the start of the previous block.

   963     \value PreviousCharacter Move to the previous character.

   964     \value PreviousWord Move to the beginning of the previous word.

   965     \value Up Move up one line.

   966     \value Left Move left one character.

   967     \value WordLeft Move left one word.

   968 

   969     \value End Move to the end of the document.

   970     \value EndOfLine Move to the end of the current line.

   971     \value EndOfWord Move to the end of the current word.

   972     \value EndOfBlock Move to the end of the current block.

   973     \value NextBlock Move to the beginning of the next block.

   974     \value NextCharacter Move to the next character.

   975     \value NextWord Move to the next word.

   976     \value Down Move down one line.

   977     \value Right Move right one character.

   978     \value WordRight Move right one word.

   979 

   980     \value NextCell  Move to the beginning of the next table cell inside the

   981            current table. If the current cell is the last cell in the row, the

   982            cursor will move to the first cell in the next row.

   983     \value PreviousCell  Move to the beginning of the previous table cell

   984            inside the current table. If the current cell is the first cell in

   985            the row, the cursor will move to the last cell in the previous row.

   986     \value NextRow  Move to the first new cell of the next row in the current

   987            table.

   988     \value PreviousRow  Move to the last cell of the previous row in the

   989            current table.

   990 

   991     \sa movePosition()

   992 */

   993 

   994 /*!

   995     \enum QTextCursor::MoveMode

   996 

   997     \value MoveAnchor Moves the anchor to the same position as the cursor itself.

   998     \value KeepAnchor Keeps the anchor where it is.

   999 

  1000     If the anchor() is kept where it is and the position() is moved,

  1001     the text in between will be selected.

  1002 */

  1003 

  1004 /*!

  1005     \enum QTextCursor::SelectionType

  1006 

  1007     This enum describes the types of selection that can be applied with the

  1008     select() function.

  1009 

  1010     \value Document         Selects the entire document.

  1011     \value BlockUnderCursor Selects the block of text under the cursor.

  1012     \value LineUnderCursor  Selects the line of text under the cursor.

  1013     \value WordUnderCursor  Selects the word under the cursor. If the cursor

  1014            is not positioned within a string of selectable characters, no

  1015            text is selected.

  1016 */

  1017 

  1018 /*!

  1019     Constructs a null cursor.

  1020  */

  1021 QTextCursor::QTextCursor()

  1022     : d(0)

  1023 {

  1024 }

  1025 

  1026 /*!

  1027     Constructs a cursor pointing to the beginning of the \a document.

  1028  */

  1029 QTextCursor::QTextCursor(QTextDocument *document)

  1030     : d(new QTextCursorPrivate(document->docHandle()))

  1031 {

  1032 }

  1033 

  1034 /*!

  1035     Constructs a cursor pointing to the beginning of the \a frame.

  1036 */

  1037 QTextCursor::QTextCursor(QTextFrame *frame)

  1038     : d(new QTextCursorPrivate(frame->document()->docHandle()))

  1039 {

  1040     d->adjusted_anchor = d->anchor = d->position = frame->firstPosition();

  1041 }

  1042 

  1043 

  1044 /*!

  1045     Constructs a cursor pointing to the beginning of the \a block.

  1046 */

  1047 QTextCursor::QTextCursor(const QTextBlock &block)

  1048     : d(new QTextCursorPrivate(block.docHandle()))

  1049 {

  1050     d->adjusted_anchor = d->anchor = d->position = block.position();

  1051 }

  1052 

  1053 

  1054 /*!

  1055   \internal

  1056  */

  1057 QTextCursor::QTextCursor(QTextDocumentPrivate *p, int pos)

  1058     : d(new QTextCursorPrivate(p))

  1059 {

  1060     d->adjusted_anchor = d->anchor = d->position = pos;

  1061 

  1062     d->setX();

  1063 }

  1064 

  1065 /*!

  1066     \internal

  1067 */

  1068 QTextCursor::QTextCursor(QTextCursorPrivate *d)

  1069 {

  1070     Q_ASSERT(d);

  1071     this->d = d;

  1072 }

  1073 

  1074 /*!

  1075     Constructs a new cursor that is a copy of \a cursor.

  1076  */

  1077 QTextCursor::QTextCursor(const QTextCursor &cursor)

  1078 {

  1079     d = cursor.d;

  1080 }

  1081 

  1082 /*!

  1083     Makes a copy of \a cursor and assigns it to this QTextCursor. Note

  1084     that QTextCursor is an \l{Implicitly Shared Classes}{implicitly

  1085     shared} class.

  1086 

  1087  */

  1088 QTextCursor &QTextCursor::operator=(const QTextCursor &cursor)

  1089 {

  1090     d = cursor.d;

  1091     return *this;

  1092 }

  1093 

  1094 /*!

  1095     Destroys the QTextCursor.

  1096  */

  1097 QTextCursor::~QTextCursor()

  1098 {

  1099 }

  1100 

  1101 /*!

  1102     Returns true if the cursor is null; otherwise returns false. A null

  1103     cursor is created by the default constructor.

  1104  */

  1105 bool QTextCursor::isNull() const

  1106 {

  1107     return !d || !d->priv;

  1108 }

  1109 

  1110 /*!

  1111     Moves the cursor to the absolute position in the document specified by

  1112     \a pos using a \c MoveMode specified by \a m. The cursor is positioned

  1113     between characters.

  1114 

  1115     \sa position() movePosition() anchor()

  1116 */

  1117 void QTextCursor::setPosition(int pos, MoveMode m)

  1118 {

  1119     if (!d || !d->priv)

  1120         return;

  1121 

  1122     if (pos < 0 || pos >= d->priv->length()) {

  1123         qWarning("QTextCursor::setPosition: Position '%d' out of range", pos);

  1124         return;

  1125     }

  1126 

  1127     d->setPosition(pos);

  1128     if (m == MoveAnchor) {

  1129         d->anchor = pos;

  1130         d->adjusted_anchor = pos;

  1131     } else { // keep anchor

  1132         QTextCursor::MoveOperation op;

  1133         if (pos < d->anchor)

  1134             op = QTextCursor::Left;