C++ QTextCursor函数代码示例

PersistentState::PersistentState(Editor *context) : EditorState(context) {
	_mousePressed = false;
	_mightStartDrag = false;
	
	_persistentCursor = QTextCursor();
	_dndFeedbackCursor = QTextCursor();
}

bool Document::eventFilter(QObject* watched, QEvent* event)
{
	if (event->type() == QEvent::MouseMove) {
		mouseMoveEvent(static_cast<QMouseEvent*>(event));
	} else if (event->type() == QEvent::KeyPress && watched == m_text) {
		int msecs = m_time.restart();
		if (msecs < 30000) {
			m_current_time += msecs;
		}
		QKeyEvent* key_event = static_cast<QKeyEvent*>(event);

                if(key_event->key()==Qt::Key_Return)
                {
                    QTextCursor testcursor(m_text->document());
                    testcursor.setPosition(m_text->textCursor().anchor());
                    int ancblock=testcursor.blockNumber();
                    testcursor.setPosition(m_text->textCursor().position());
                    int curblock=testcursor.blockNumber();
                    if(curblock==ancblock)
                    {
                        QString uprop=testcursor.blockFormat().stringProperty(QTextFormat::UserProperty);
                        if(uprop=="ATTRIBUTION" || uprop.startsWith("DIVIDER"))
                        {
                            testcursor.insertBlock(defaultFormatForBlock(""));
                            return true;
                        }
                    }
                }


                if (!key_event->text().isEmpty())
                {
                        QTextCursor testcursor2=QTextCursor(m_text->textCursor());
                        if(testcursor2.anchor()==testcursor2.position()&&testcursor2.atBlockStart()&&testcursor2.blockFormat().stringProperty(QTextFormat::UserProperty).startsWith("DIVIDER"))
                            return true;
                        if(SmartQuotes::isEnabled()&&key_event->text()=="-")
                        {
                                QTextCursor testcursor=QTextCursor(m_text->document());
                                int ancpos=m_text->textCursor().anchor();
                                int curpos=m_text->textCursor().position();
                                testcursor.setPosition(ancpos<curpos?ancpos:curpos);
                                if(!testcursor.atBlockStart())
                                {
                                    testcursor.movePosition(QTextCursor::Left,QTextCursor::KeepAnchor);
                                    if(testcursor.selectedText()=="-")
                                    {
                                        testcursor.insertText(QString(QChar(0x2014)));
                                        m_text->textCursor().removeSelectedText();
                                        return true;
                                    }
                                }
                        }
			emit keyPressed(key_event->key());
		}
		if (SmartQuotes::isEnabled() && SmartQuotes::insert(m_text, key_event)) {
			return true;
		}
	}
	return QWidget::eventFilter(watched, event);
}

/*!
    \fn QTextCursor QTextTable::rowStart(const QTextCursor &cursor) const

    Returns a cursor pointing to the start of the row that contains the
    given \a cursor.

    \sa rowEnd()
*/
QTextCursor QTextTable::rowStart(const QTextCursor &c) const
{
    Q_D(const QTextTable);
    QTextTableCell cell = cellAt(c);
    if (!cell.isValid())
        return QTextCursor();

    int row = cell.row();
    QTextDocumentPrivate *p = d->pieceTable;
    QTextDocumentPrivate::FragmentIterator it(&p->fragmentMap(), d->grid[row*d->nCols]);
    return QTextCursor(p, it.position());
}

void RTF::Reader::read(QIODevice* device, QTextDocument* text)
{
	try {
		// Open file
		m_text = 0;
		if (!m_cursor.isNull()) {
			m_cursor = QTextCursor();
		}
		m_text = text;
		m_cursor = QTextCursor(m_text);
		m_cursor.movePosition(QTextCursor::End);
		m_token.setDevice(device);
		setBlockDirection(Qt::LeftToRight);

		// Check file type
		m_token.readNext();
		if (m_token.type() == StartGroupToken) {
			pushState();
		} else {
			throw tr("Not a supported RTF file.");
		}
		m_token.readNext();
		if (m_token.type() != ControlWordToken || m_token.text() != "rtf" || m_token.value() != 1) {
			throw tr("Not a supported RTF file.");
		}

		// Parse file contents
		while (!m_states.isEmpty() && m_token.hasNext()) {
			m_token.readNext();

			if ((m_token.type() != EndGroupToken) && !m_in_block) {
				m_cursor.insertBlock();
				m_in_block = true;
			}

			if (m_token.type() == StartGroupToken) {
				pushState();
			} else if (m_token.type() == EndGroupToken) {
				popState();
			} else if (m_token.type() == ControlWordToken) {
				if (!m_state.ignore_control_word && functions.contains(m_token.text())) {
					functions[m_token.text()].call(this, m_token);
				}
			} else if (m_token.type() == TextToken) {
				if (!m_state.ignore_text) {
					m_cursor.insertText(m_codec->toUnicode(m_token.text()));
				}
			}
		}
	} catch (const QString& error) {
		m_error = error;
	}
}

/*!
    \fn QTextCursor QTextTable::rowEnd(const QTextCursor &cursor) const

    Returns a cursor pointing to the end of the row that contains the given
    \a cursor.

    \sa rowStart()
*/
QTextCursor QTextTable::rowEnd(const QTextCursor &c) const
{
    Q_D(const QTextTable);
    QTextTableCell cell = cellAt(c);
    if (!cell.isValid())
        return QTextCursor();

    int row = cell.row() + 1;
    int fragment = row < d->nRows ? d->grid[row*d->nCols] : d->fragment_end;
    QTextDocumentPrivate *p = d->pieceTable;
    QTextDocumentPrivate::FragmentIterator it(&p->fragmentMap(), fragment);
    return QTextCursor(p, it.position() - 1);
}

QTextCursor DocumentHandler::textCursor() const
{
    if (!m_doc)
        return QTextCursor();

    QTextCursor cursor = QTextCursor(m_doc);
    if (m_selectionStart != m_selectionEnd) {
        cursor.setPosition(m_selectionStart);
        cursor.setPosition(m_selectionEnd, QTextCursor::KeepAnchor);
    } else {
        cursor.setPosition(m_cursorPosition);
    }
    return cursor;
}

QTextCursor ScCodeEditor::selectionForPosition( int position )
{
    QTextBlock block( textDocument()->findBlock(position) );
    if (!block.isValid())
        return QTextCursor();

    int positionInBlock = position - block.position();

    TokenIterator it = TokenIterator( block, positionInBlock );
    if (it.type() == Token::Unknown) {
        // Token is invalid, or Token::Unknown (i.e. punctuations).
        // Prefer token at previous position.
        TokenIterator alternativeIt = TokenIterator( block, positionInBlock - 1 );
        if (alternativeIt.isValid())
            it = alternativeIt;
    }

    if (it.isValid()) {
        switch (it->type) {
        case Token::OpeningBracket:
        case Token::ClosingBracket:
        {
            BracketPair match;
            matchBracket(it, match);
            if (match.first.isValid() && match.second.isValid()) {
                int start = match.first.position();
                int end = match.second.position() + 1;
                QTextCursor selection(textDocument());
                if (it == match.second) {
                    selection.setPosition(start);
                    selection.setPosition(end, QTextCursor::KeepAnchor);
                } else {
                    selection.setPosition(end);
                    selection.setPosition(start, QTextCursor::KeepAnchor);
                }
                return selection;
            }
            break;
        }

        default:
            QTextCursor selection( textDocument() );
            selection.setPosition( it.position() );
            selection.setPosition( selection.position() + it->length, QTextCursor::KeepAnchor );
            return selection;
        }
    }

    return QTextCursor();
}

void PersistentState::initialize() {
	_dndFeedbackCursor = QTextCursor();
	
	QTextCursor textCursor = editor()->textCursor();
	if (textCursor.hasSelection()) {
		_persistentCursor = textCursor;
		textCursor.clearSelection();
		editor()->setTextCursor(textCursor);
	}
	else
		_persistentCursor = QTextCursor();

	connect(editor(), SIGNAL(selectionChanged()), this, SLOT(editorSelectionChange()) );
}

QTextCursor QTextEditProto::textCursor() const
{
  QTextEdit *item = qscriptvalue_cast<QTextEdit*>(thisObject());
  if (item)
    return item->textCursor();
  return QTextCursor();
}

void QScriptEdit::updateExtraSelections()
{
    QList<QTextEdit::ExtraSelection> extraSelections;

    {
        QTextEdit::ExtraSelection selection;
        QColor lineColor = QColor(Qt::yellow).lighter(160);
        selection.format.setBackground(lineColor);
        selection.format.setProperty(QTextFormat::FullWidthSelection, true);
        selection.cursor = textCursor();
        selection.cursor.clearSelection();
        extraSelections.append(selection);
    }
    if (m_executionLineNumber != -1) {
        QTextEdit::ExtraSelection selection;
        QColor lineColor;
        if (m_executionLineNumberHasError)
            lineColor = QColor(Qt::red);
        else
            lineColor = QColor(Qt::green).lighter(160);
        selection.format.setBackground(lineColor);
        selection.format.setProperty(QTextFormat::FullWidthSelection, true);
        int blockNumber = m_executionLineNumber - m_baseLineNumber;
        selection.cursor = QTextCursor(document()->findBlockByNumber(blockNumber));
        selection.cursor.clearSelection();
        extraSelections.append(selection);
    }

    setExtraSelections(extraSelections);
}

void DocBlock::addLink(QUrl url)
{
    myTextItem->setTextInteractionFlags(Qt::TextSelectableByKeyboard);
    docType = Link;
    path = url.toString();
    QString str = path;

    // add file icon
    QTextCursor cursor = QTextCursor(myTextItem->document());
    QFileInfo info(url.toLocalFile());
    QFileIconProvider *provider = new QFileIconProvider();
    QImage image(provider->icon(info).pixmap(16, 16).toImage());
    cursor.document()->setPlainText(" ");
    cursor.insertImage(image);
	
    if (str.lastIndexOf("/") > -1)
        str = str.right(str.size() - str.lastIndexOf("/") - 1);

    QString html = "<a href=\""+path+"\">"+str+"</a>";
    cursor.insertHtml(html);
	
    if (arrow != 0) arrow->setColor(getHoverColor());

    updateBlock(false);
}

void ElementTitle::startTextInteraction()
{
	parentItem()->setSelected(true);

	// Already interacting?
	if (hasFocus())
		return;

	mOldText = toPlainText();

	// Clear scene selection
	//if (!(event->modifiers() & Qt::ControlModifier)) - was here.
	scene()->clearSelection();

	if (mReadOnly)
		setTextInteractionFlags(Qt::TextBrowserInteraction);
	else
		setTextInteractionFlags(Qt::TextEditorInteraction);
	setFocus(Qt::OtherFocusReason);

	// Set full text selection
	QTextCursor cursor = QTextCursor(document());
	cursor.select(QTextCursor::Document);
	setTextCursor(cursor);
	setCursor(Qt::IBeamCursor);
}

QTextCursor ScCodeEditor::regionAroundCursor(const QTextCursor & cursor)
{
    int cursorPosition = cursor.position();

    BracketPair bracketPair;
    TokenIterator it = TokenIterator::rightOf( textDocument()->begin(), 0 );
    while (it.isValid()) {
        nextBracketPair(it, bracketPair);
        if (bracketPair.first.isValid() && bracketPair.first.position() < cursorPosition)
        {
            if ( bracketPair.second.isValid() && bracketPair.second.position() >= cursorPosition
                 && bracketPairDefinesRegion(bracketPair) )
            {
                QTextCursor regionCursor(QPlainTextEdit::document());
                regionCursor.setPosition(bracketPair.first.position() + 1);
                regionCursor.setPosition(bracketPair.second.position(), QTextCursor::KeepAnchor);
                return regionCursor;
            }
        } else {
            break;
        }

        it = bracketPair.second;
    }

    return QTextCursor();
}

QTextDocument *ReplaceDocument::fileDocument(const QString &fileName, QTextCursor &cursor, bool &crlf)
{
    LiteApi::IEditor *editor = m_liteApp->editorManager()->findEditor(fileName,true);
    if (editor) {
        QPlainTextEdit *ed = LiteApi::getPlainTextEdit(editor);
        if (ed) {
            cursor = ed->textCursor();
            return ed->document();
        }
    }
    QFile file(fileName);
    if (file.open(QFile::ReadOnly)) {
        QByteArray data = file.readAll();
        QString text = QString::fromUtf8(data);
        int lf = text.indexOf('\n');
        if (lf <= 0) {
            crlf = false;
        } else {
            lf = text.indexOf(QRegExp("[^\r]\n"),lf-1);
            if (lf >= 0) {
                crlf = false;
            } else {
                crlf = true;
            }
        }
        m_document = new QTextDocument(text);
        cursor = QTextCursor(m_document);
        return m_document;
    }
    return 0;
}

void MyTextEdit::highlightLines()
 {
	 QList<QTextEdit::ExtraSelection> extraSelections;

	 if (!isReadOnly())
	 {
		 QTextEdit::ExtraSelection selection;

		 for(QMap<int, QColor>::const_iterator it = m_highlightedLines.begin(); it != m_highlightedLines.end(); ++it)
		 {
			 selection.format.setBackground(it.value());
			 selection.format.setProperty(QTextFormat::FullWidthSelection, true);
			 selection.cursor = QTextCursor(document());
			 selection.cursor.setPosition(document()->findBlockByLineNumber(it.key()).position());
			 extraSelections.append(selection);
		 }

		 selection.format.setBackground(QColor(Qt::yellow).lighter(170));
		 selection.format.setProperty(QTextFormat::FullWidthSelection, true);
		 selection.cursor = textCursor();
		 selection.cursor.clearSelection();
		 extraSelections.append(selection);
	 }

	 setExtraSelections(extraSelections);
 }