void CodeEditer::keyPressEvent(QKeyEvent *e) { if (e == QKeySequence::InsertParagraphSeparator || e == QKeySequence::InsertLineSeparator) { QTextCursor cursor = textCursor(); //if (d->m_inBlockSelectionMode) //cursor.clearSelection(); //if (d->m_document->tabSettings().m_autoIndent) { cursor.beginEditBlock(); cursor.insertBlock(); indent(document(), cursor, QChar::Null); cursor.endEditBlock(); //} else { //cursor.insertBlock(); //} e->accept(); setTextCursor(cursor); return; } e->accept(); QPlainTextEdit::keyPressEvent(e); }
void CompleterTextEditWidget::comment(){ QTextCursor c(textCursor()); if (c.selectionStart() == c.selectionEnd()) { c.movePosition(QTextCursor::StartOfLine); c.insertText(commentString+" "); //setTextCursor(c); } else { // now we have to iterate through all selected blocks (lines) and indent them QTextCursor c1(c); c1.setPosition(c.selectionStart()); QTextCursor c2(c); c2.setPosition(c.selectionEnd()); c1.beginEditBlock(); while (c1.blockNumber() <= c2.blockNumber()) { c1.movePosition(QTextCursor::StartOfBlock); c1.insertText(commentString+" "); if (!c1.movePosition(QTextCursor::NextBlock)) break; } c1.endEditBlock(); setTextCursor(c); } }
void ConsoleOutput::timerEvent(QTimerEvent *e) { if(e->timerId() != m_timerId) return; poll(); if(m_captured.isEmpty()) return; // make sure no text is selected, move cursor to end of document QTextCursor crs = textCursor(); crs.clearSelection(); crs.movePosition(QTextCursor::End); setTextCursor(crs); if (m_parseColors) { printColorCoded(m_captured); } else { QRegExp rx("\033\[[0-9;]*m"); QString str = m_captured; str.remove(rx); textCursor().insertText(str); }
void PythonQtScriptingConsole::executeCode(const QString& code) { // put visible cursor to the end of the line QTextCursor cursor = QTextEdit::textCursor(); cursor.movePosition(QTextCursor::End); setTextCursor(cursor); int cursorPosition = this->textCursor().position(); // evaluate the code _stdOut = ""; _stdErr = ""; PythonQtObjectPtr p; PyObject* dict = NULL; if (PyModule_Check(_context)) { dict = PyModule_GetDict(_context); } else if (PyDict_Check(_context)) { dict = _context; } if (dict) { p.setNewRef(PyRun_String(code.toLatin1().data(), Py_single_input, dict, dict)); } if (!p) { PythonQt::self()->handleError(); } flushStdOut(); bool messageInserted = (this->textCursor().position() != cursorPosition); // If a message was inserted, then put another empty line before the command prompt // to improve readability. if (messageInserted) { append(QString()); } }
void ScCodeEditor::evaluateRegion() { QString text; // Try current selection QTextCursor cursor = textCursor(); if (cursor.hasSelection()) text = cursor.selectedText(); else { // If no selection, try current region cursor = currentRegion(); if (!cursor.isNull()) { text = cursor.selectedText(); } else { // If no current region, try current line cursor = textCursor(); text = cursor.block().text(); if( mStepForwardEvaluation ) { QTextCursor newCursor = cursor; newCursor.movePosition(QTextCursor::NextBlock); setTextCursor(newCursor); } // Adjust cursor for code blinking: cursor.movePosition(QTextCursor::StartOfBlock); cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor); } } if (text.isEmpty()) return; text.replace( QChar( 0x2029 ), QChar( '\n' ) ); Main::evaluateCode(text); blinkCode( cursor ); }
void OpenedFile::replaceLine(const int line_number, const QString &new_line) { QString old_text; QString new_text = new_line; QTextCursor parsingCursor = textCursor(); int space_count = 0; parsingCursor.setPosition(0); while(parsingCursor.blockNumber() != line_number) { parsingCursor.movePosition(QTextCursor::Down); } parsingCursor.movePosition(QTextCursor::StartOfLine); parsingCursor.movePosition(QTextCursor::EndOfLine, QTextCursor::KeepAnchor); old_text = parsingCursor.selectedText(); while(old_text.startsWith(" ")) { old_text.remove(0,1); space_count++; } while(space_count>0) { new_text.prepend(" "); space_count--; } new_text.remove(".0000"); parsingCursor.insertText(new_text); parsingCursor.clearSelection(); setTextCursor(parsingCursor); }
void CSVWorld::ScriptEdit::dropEvent (QDropEvent* event) { const CSMWorld::TableMimeData* mime = dynamic_cast<const CSMWorld::TableMimeData*> (event->mimeData()); setTextCursor (cursorForPosition (event->pos())); if (mime->fromDocument (mDocument)) { std::vector<CSMWorld::UniversalId> records (mime->getData()); for (std::vector<CSMWorld::UniversalId>::iterator it = records.begin(); it != records.end(); ++it) { if (mAllowedTypes.contains (it->getType())) { if (stringNeedsQuote(it->getId())) { insertPlainText(QString::fromUtf8 (('"' + it->getId() + '"').c_str())); } else { insertPlainText(QString::fromUtf8 (it->getId().c_str())); } } } } }
void CodeEditor::completeText(const QString &text) { textCursor().beginEditBlock(); QTextCursor editingTextCursor = textCursor(); editingTextCursor.setPosition(textCursor().selectionEnd()); editingTextCursor.movePosition(QTextCursor::PreviousWord, QTextCursor::KeepAnchor); editingTextCursor.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor); if(editingTextCursor.selectedText().contains('-')) { editingTextCursor.movePosition(QTextCursor::PreviousWord, QTextCursor::KeepAnchor); } else { editingTextCursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor); } editingTextCursor.removeSelectedText(); editingTextCursor.insertText(text); setTextCursor(editingTextCursor); textCursor().endEditBlock(); }
void QScrollDownTextBrowser::insertHtml(const QString &text) { QScrollBar * b = verticalScrollBar(); if (linecount >= 2000 && autoClear) { keepLines(1000); moveCursor(QTextCursor::End); linecount = 1000; QTextBrowser::insertHtml(text); b->setValue(b->maximum()); return; } int f = b->value(); int e = b->maximum(); /* Stores cursor state before moving it in case we need it later */ QTextCursor cursor = this->textCursor(); moveCursor(QTextCursor::End); QTextBrowser::insertHtml(text); /* If we had something highlighted, restore it */ if (cursor.selectionEnd() != cursor.selectionStart()) { setTextCursor(cursor); } if(f != e) { b->setValue(f); } else { b->setValue(b->maximum()); } linecount++; }
void AMGraphicsTextItem::changingText() { int initialPosition = textCursor().position(); QTextCursor newPosition = textCursor(); int anchorPositon = newPosition.anchor(); if(textCursor().atStart()) initialPosition = -2; emit textChanged(shapeIndex_); if(initialPosition == -1) { initialPosition++; } else if (initialPosition == -2) { newPosition.setPosition(0); } else newPosition.setPosition(initialPosition); newPosition.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor,newPosition.position() - anchorPositon); setTextCursor(newPosition); setSelectAll(false); }
void QFCompleterTextEditWidget::uncomment(){ QTextCursor c(textCursor()); if (c.selectionStart() == c.selectionEnd()) { c.select(QTextCursor::LineUnderCursor); c.insertText(removeComments(c.selectedText())); //setTextCursor(c); } else { // now we have to iterate through all selected blocks (lines) and indent them QTextCursor c1(c); c1.setPosition(c.selectionStart()); QTextCursor c2(c); c2.setPosition(c.selectionEnd()); c1.beginEditBlock(); while (c1.blockNumber() <= c2.blockNumber()) { c1.select(QTextCursor::BlockUnderCursor); //std::cout<<"'"<<c1.selectedText().toLatin1().data()<<"' => '"<<removeComments(c1.selectedText()).toLatin1().data()<<"'"<<std::endl; c1.insertText(removeComments(c1.selectedText())); if (!c1.movePosition(QTextCursor::NextBlock)) break; } c1.endEditBlock(); setTextCursor(c); } }
bool GenericCodeEditor::find( const QRegExp &expr, QTextDocument::FindFlags options ) { // Although QTextDocument provides a find() method, we implement // our own, because the former one is not adequate. if(expr.isEmpty()) return true; bool backwards = options & QTextDocument::FindBackward; QTextCursor c( textCursor() ); int pos; if (c.hasSelection()) { bool matching = expr.exactMatch(c.selectedText()); if( backwards == matching ) pos = c.selectionStart(); else pos = c.selectionEnd(); } else pos = c.position(); QTextDocument *doc = QPlainTextEdit::document(); QTextBlock startBlock = doc->findBlock(pos); int startBlockOffset = pos - startBlock.position(); QTextCursor cursor; if (!backwards) { int blockOffset = startBlockOffset; QTextBlock block = startBlock; while (block.isValid()) { if (findInBlock(doc, block, expr, blockOffset, options, cursor)) break; blockOffset = 0; block = block.next(); } if(cursor.isNull()) { blockOffset = 0; block = doc->begin(); while(true) { if (findInBlock(doc, block, expr, blockOffset, options, cursor) || block == startBlock) break; block = block.next(); } } } else { int blockOffset = startBlockOffset; QTextBlock block = startBlock; while (block.isValid()) { if (findInBlock(doc, block, expr, blockOffset, options, cursor)) break; block = block.previous(); blockOffset = block.length() - 1; } if(cursor.isNull()) { block = doc->end(); while(true) { blockOffset = block.length() - 1; if (findInBlock(doc, block, expr, blockOffset, options, cursor) || block == startBlock) break; block = block.previous(); } } } if(!cursor.isNull()) { setTextCursor(cursor); return true; } else return false; }
//------------------------------------------------------------------------------------------------- void QCommandPrompt::keyPressEvent(QKeyEvent *e) { // Wenn Enter gedrückt wird, wird die Eingabe als Kommando interpretiert switch(e->key()) { case Qt::Key_Return: { // Alles zwischen Promptposition und dem Textende ist das Kommando QString sAll = toPlainText(); QString sCmd = sAll.right(sAll.count() - m_nPromptPos); if (sCmd.length()>0 && (m_vHistory.size()==0 || m_vHistory.back()!=sCmd) ) { m_vHistory.push_back(sCmd); while (m_vHistory.size() > m_nMaxHist) m_vHistory.removeFirst(); m_nHistPos = m_vHistory.size() - 1; } sCmd = sCmd.trimmed(); if (!sCmd.isEmpty()) { addLine(getPrompt() + sCmd.trimmed()); emit commandInput(sCmd); } // Textcursor ans Ende versetzen QTextCursor tc = textCursor(); tc.movePosition(QTextCursor::End); setTextCursor(tc); } break; case Qt::Key_Up: case Qt::Key_Down: if (m_vHistory.size()==0) break; clearLineExceptPrompt(); insertPlainText(m_vHistory[m_nHistPos]); m_nHistPos = m_nHistPos + ((e->key()==Qt::Key_Up) ? -1 : 1); m_nHistPos = Utils::clamp(0, m_vHistory.size()-1, m_nHistPos); break; case Qt::Key_Home: { QTextCursor tc = textCursor(); Qt::KeyboardModifiers mod = e->modifiers(); if (mod & Qt::ShiftModifier) tc.setPosition(m_nPromptPos, QTextCursor::KeepAnchor); else tc.setPosition(m_nPromptPos, QTextCursor::MoveAnchor); setTextCursor(tc); } break; case Qt::Key_Backspace: case Qt::Key_Left: { int nPos = textCursor().position(); if (nPos > m_nPromptPos) QPlainTextEdit::keyPressEvent(e); } break; default: { int nPos = textCursor().position(); if (nPos < m_nPromptPos) { QTextCursor tc = textCursor(); tc.movePosition(QTextCursor::End); setTextCursor(tc); } QPlainTextEdit::keyPressEvent(e); } } }
void UBGraphicsTextItem::mousePressEvent(QGraphicsSceneMouseEvent *event) { setTextInteractionFlags(Qt::TextEditorInteraction); // scene()->itemAt(pos) returns 0 if pos is not over text, but over text item, but mouse press comes. // It is a cludge... if (UBStylusTool::Play == UBDrawingController::drawingController()->stylusTool()) { QGraphicsTextItem::mousePressEvent(event); event->accept(); clearFocus(); return; } if (Delegate()) { Delegate()->mousePressEvent(event); if (Delegate() && parentItem() && UBGraphicsGroupContainerItem::Type == parentItem()->type()) { UBGraphicsGroupContainerItem *group = qgraphicsitem_cast<UBGraphicsGroupContainerItem*>(parentItem()); if (group) { QGraphicsItem *curItem = group->getCurrentItem(); if (curItem && this != curItem) { group->deselectCurrentItem(); } group->setCurrentItem(this); this->setSelected(true); Delegate()->positionHandles(); } } else { Delegate()->getToolBarItem()->show(); } } if (!data(UBGraphicsItemData::ItemEditable).toBool()) return; int elapsed = mLastMousePressTime.msecsTo(QTime::currentTime()); if (elapsed < UBApplication::app()->doubleClickInterval()) { mMultiClickState++; if (mMultiClickState > 3) mMultiClickState = 1; } else { mMultiClickState = 1; } mLastMousePressTime = QTime::currentTime(); if (mMultiClickState == 1) { QGraphicsTextItem::mousePressEvent(event); setFocus(); } else if (mMultiClickState == 2) { QTextCursor tc= textCursor(); tc.select(QTextCursor::WordUnderCursor); setTextCursor(tc); } else if (mMultiClickState == 3) { QTextCursor tc= textCursor(); tc.select(QTextCursor::Document); setTextCursor(tc); } else { mMultiClickState = 0; } }
void Console::printWithFormat(const QString& str, const QTextCharFormat& fmt) { const QString escape = QStringLiteral("\x1b["); QTextCursor cur(document()->lastBlock()); cur.movePosition((QTextCursor::StartOfBlock)); cur.setCharFormat(fmt); int startIndex = 0; while(true) { int escapeIndex = str.indexOf(escape, startIndex); if (escapeIndex == -1) { // no more escape codes found, output rest of string cur.insertText(str.mid(startIndex, str.length()-startIndex)); break; } // escape code found, output everything up to it cur.insertText(str.mid(startIndex, escapeIndex-startIndex)); // look for 'm', the termination character for graphic escape codes int termIndex = str.indexOf('m', escapeIndex); // if didn't find termination code, jump over escape sequence and loop if (termIndex == -1) { startIndex = escapeIndex + escape.size(); continue; } // found termination code, set startIndex for next loop iteration startIndex = termIndex + 1; // extract payload: should be one or more numbers separated by semicolons int formatCodeStart = escapeIndex + escape.size(); // read format codes while (formatCodeStart < termIndex) { // Look for digits int formatCodeEnd = formatCodeStart; while (str[formatCodeEnd].isDigit() && formatCodeEnd < termIndex) { formatCodeEnd++; } // abort if we overran the escape sequence if (formatCodeEnd > termIndex) break; // convert to number QStringRef formatCodeString = str.midRef(formatCodeStart, formatCodeEnd-formatCodeStart); bool ok = false; int formatCode = formatCodeString.toUInt(&ok); if (!ok) break; applyFormatCode(cur, formatCode); // if a semicolon follows, loop again, otherwise we're done if (str[formatCodeEnd] != ';') break; formatCodeStart = formatCodeEnd + 1; } } if (!str.endsWith("\n")) { cur.insertBlock(); } setTextCursor(cur); moveToEndOfCommandLine(); }
void Console::keyPressEvent(QKeyEvent *event) { if (event->key() == Qt::Key_Return) // process command { if (m_completer && m_completer->popup()->isVisible()) { event->ignore(); return; } else { processCommand(); } return; } if (inCommandLine()) { // clear selection that spans multiple blocks (or prefix characters) (would overwrite previous command lines): QTextCursor cur = textCursor(); if (cur.hasSelection()) { if (document()->findBlock(cur.selectionStart()) != document()->findBlock(cur.selectionEnd()) || // spans multiple blocks (including command line) cur.selectionStart()-cur.block().position() < m_prefix.length() || // spans prefix cur.selectionEnd()-cur.block().position() < m_prefix.length() ) // spans prefix { cur.clearSelection(); if (cur.positionInBlock() < m_prefix.length()) cur.setPosition(cur.block().position()+m_prefix.length()); setTextCursor(cur); } } if (cur.positionInBlock() == m_prefix.length()) { cur.setCharFormat(QTextCharFormat()); // make sure we don't pick up format from prefix setTextCursor(cur); } // react to keystroke: if (event->matches(QKeySequence::MoveToPreviousLine)) // history up { if (m_history.isEmpty() || m_historyPos >= m_history.size()-1) return; ++m_historyPos; int index = m_history.size()-m_historyPos-1; QTextCursor cur(document()->lastBlock()); cur.movePosition(QTextCursor::NextCharacter, QTextCursor::MoveAnchor, m_prefix.length()); cur.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor); cur.removeSelectedText(); cur.setCharFormat(QTextCharFormat()); cur.insertText(m_history.at(index)); setTextCursor(cur); } else if (event->matches(QKeySequence::MoveToNextLine)) // history down { if (m_history.isEmpty() || m_historyPos <= 0) return; --m_historyPos; int index = m_history.size()-m_historyPos-1; QTextCursor cur(document()->lastBlock()); cur.movePosition(QTextCursor::NextCharacter, QTextCursor::MoveAnchor, m_prefix.length()); cur.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor); cur.removeSelectedText(); cur.setCharFormat(QTextCharFormat()); cur.insertText(m_history.at(index)); setTextCursor(cur); } else if (event->matches(QKeySequence::Paste)) // paste text, do it manually to remove text char formatting and newlines { QString pasteText = QApplication::clipboard()->text(); pasteText.replace("\n", "").replace("\r", ""); cur.setCharFormat(QTextCharFormat()); cur.insertText(pasteText); setTextCursor(cur); } else if (event->key() == Qt::Key_Backspace || event->matches(QKeySequence::MoveToPreviousChar)) // only allow backspace if we wouldn't delete last char of prefix, similar left arrow { if (cur.positionInBlock() > m_prefix.length()) QPlainTextEdit::keyPressEvent(event); } else if (event->matches(QKeySequence::MoveToStartOfLine) || event->key() == Qt::Key_Home) { // Don't move past prefix when pressing home // OSX treats the home key as MoveToStartOfDocument, so including the key code here too cur.movePosition(QTextCursor::PreviousCharacter, event->modifiers() & Qt::ShiftModifier ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor, cur.positionInBlock() - m_prefix.length()); cur.setCharFormat(QTextCharFormat()); setTextCursor(cur); } else if (event->key() == Qt::Key_Escape) { if (m_completer && m_completer->popup()->isVisible()) { m_completer->popup()->hide(); } else { QTextCursor cur(document()->lastBlock()); cur.movePosition(QTextCursor::NextCharacter, QTextCursor::MoveAnchor, m_prefix.length()); cur.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor); cur.removeSelectedText(); setTextCursor(cur); } } else if (event->key() == Qt::Key_Tab) { if (m_completer) { m_completer->setCompletionPrefix(currentWord()); QRect cr = cursorRect(); cr.setWidth(m_completer->popup()->sizeHintForColumn(0) + m_completer->popup()->verticalScrollBar()->sizeHint().width()); m_completer->complete(cr); } } else if (!event->matches(QKeySequence::Close) && !event->matches(QKeySequence::New) && !event->matches(QKeySequence::Open) && !event->matches(QKeySequence::Preferences) && !event->matches(QKeySequence::Bold) && !event->matches(QKeySequence::Italic) && !event->matches(QKeySequence::InsertLineSeparator) && !event->matches(QKeySequence::InsertParagraphSeparator) && !event->matches(QKeySequence::Redo) && !event->matches(QKeySequence::Undo) && !event->matches(QKeySequence::DeleteStartOfWord)) { QPlainTextEdit::keyPressEvent(event); } } else // cursor position not in command line { if (event->matches(QKeySequence::MoveToEndOfDocument) || event->matches(QKeySequence::MoveToEndOfBlock) || event->matches(QKeySequence::MoveToEndOfLine) || event->matches(QKeySequence::MoveToStartOfDocument) || event->matches(QKeySequence::MoveToStartOfBlock) || event->matches(QKeySequence::MoveToStartOfLine) || //event->matches(QKeySequence::MoveToNextLine) || event->matches(QKeySequence::MoveToNextWord) || event->matches(QKeySequence::MoveToNextChar) || //event->matches(QKeySequence::MoveToPreviousLine) || event->matches(QKeySequence::MoveToPreviousWord) || event->matches(QKeySequence::MoveToPreviousChar) || event->matches(QKeySequence::SelectAll) || event->matches(QKeySequence::SelectEndOfDocument) || event->matches(QKeySequence::SelectEndOfBlock) || event->matches(QKeySequence::SelectEndOfLine) || event->matches(QKeySequence::SelectStartOfDocument) || event->matches(QKeySequence::SelectStartOfBlock) || event->matches(QKeySequence::SelectStartOfLine) || event->matches(QKeySequence::SelectNextLine) || event->matches(QKeySequence::SelectNextWord) || event->matches(QKeySequence::SelectNextChar) || event->matches(QKeySequence::SelectPreviousLine) || event->matches(QKeySequence::SelectPreviousWord) || event->matches(QKeySequence::SelectPreviousChar) || event->matches(QKeySequence::Copy) || event->key() == Qt::Key_Shift || event->key() == Qt::Key_Alt || event->key() == Qt::Key_Control || event->key() == Qt::Key_Meta ) { QPlainTextEdit::keyPressEvent(event); } else { // Place cursor in command line moveToEndOfCommandLine(); QPlainTextEdit::keyPressEvent(event); } } }
void ScCodeEditor::selectCurrentRegion() { QTextCursor selectedRegionCursor = currentRegion(); if (!selectedRegionCursor.isNull() && selectedRegionCursor.hasSelection()) setTextCursor(selectedRegionCursor); }
void GroupedLineEdit::selectAll() { QTextCursor c = textCursor(); c.select(QTextCursor::LineUnderCursor); setTextCursor(c); }
void QFCompleterTextEditWidget::keyPressEvent(QKeyEvent *event) { if (c && c->popup()->isVisible()) { // The following keys are forwarded by the completer to the widget switch (event->key()) { case Qt::Key_Enter: case Qt::Key_Return: case Qt::Key_Escape: case Qt::Key_Tab: case Qt::Key_Backtab: event->ignore(); return; // completer widgets handles these keys! default: break; } } else { // if the completer is not visible, we may treat some special // key press events (convert TAB to spaces ... if (event->key()==Qt::Key_Tab) { // convert TAB to <tabwidth> spaces processTab(event); return; // let the completer do default behavior } else if (event->key()==Qt::Key_Backtab || (event->key()==Qt::Key_Tab && event->modifiers()==Qt::ShiftModifier)) { indentDec(); return; // let the completer do default behavior } else if (event->key()==Qt::Key_Return || event->key()==Qt::Key_Enter) { // indent when last non-space character in current line is '{' QTextCursor tc = textCursor(); // if text has been selected, the user wants to overwrite this text // with a linebreak, so we first delete the text if (tc.hasSelection()) tc.deleteChar(); //tc.select(QTextCursor::LineUnderCursor); tc.movePosition(QTextCursor::StartOfLine, QTextCursor::KeepAnchor); QString line=tc.selectedText(); // count leading spaces int lspaces=0; QChar* data=line.data(); while (data->isSpace()) { ++data; lspaces++; } // get right-most non-space character int indx=line.size()-1; data=line.data(); if (indx>=0) while (data[indx].isSpace() && (indx>0)) { indx--; } QChar last=data[indx]; if (last=='{') { QTextCursor c(textCursor()); c.insertText("\n"+QString(lspaces, QChar(' '))+tabToSpaces()); setTextCursor(c); } else if (last=='}' && line.indexOf('}')==lspaces) { // '}' is the first non-space character in this line QTextCursor c(textCursor()); QTextCursor c1(textCursor()); c1.movePosition(QTextCursor::Left, QTextCursor::KeepAnchor); QString left=c1.selectedText(); if (lspaces>0 && left=="}") { long clspaces=lspaces; // the number of leading spaces in the current line long indention=qMax((long)0, (long)lspaces-(long)tabwidth); // new number of leading spaces // here we try to find the matching '{' and reduce the indention to the // indention of the matching '{'. If the matching '{' was not found, // the indention will not be reduced QTextCursor cc(textCursor()); int cnt=1; int pos=cc.selectionStart()-2; while ((cnt>0) && (pos>=0)) { cc.setPosition(pos); cc.setPosition(pos+1, QTextCursor::KeepAnchor); QString curChar=cc.selectedText(); if (curChar=="{") cnt--; if (curChar=="}") cnt++; //std::cout<<"'"<<(char*)curChar.toLatin1().data()<<"' cnt="<<cnt<<" pos="<<pos<<std::endl; pos--; } // here we found the matching '{' and count its leading spaces if (pos>=0){ cc.select(QTextCursor::LineUnderCursor); lspaces=0; QChar* data=cc.selectedText().data(); while (data->isSpace()) { ++data; lspaces++; } indention=lspaces; } //std::cout<<"indention="<<indention<<" clspaces="<<clspaces<<" lspaces="<<lspaces<<std::endl; c=textCursor(); c.movePosition(QTextCursor::StartOfLine, QTextCursor::KeepAnchor); c.insertText(QString(indention, QChar(' '))+line.right(qMax((long)1,(long)line.size()-clspaces))+"\n"+QString(indention, QChar(' '))); //c.movePosition(QTextCursor::Left); //c.insertText("\n"+QString(lspaces, QChar(' '))); } else { c=textCursor(); c.insertText("\n"); } setTextCursor(c); } else { QTextCursor c(textCursor()); c.insertText("\n"+QString(lspaces, QChar(' '))); setTextCursor(c); } return; } } bool isShortcut = ((event->modifiers() & Qt::ControlModifier) && event->key() == Qt::Key_E); // CTRL+E if (!c || !isShortcut) // dont process the shortcut when we have a completer QTextEdit::keyPressEvent(event); const bool ctrlOrShift = event->modifiers() & (Qt::ControlModifier | Qt::ShiftModifier); if (!c || (ctrlOrShift && event->text().isEmpty())) return; static QString eow("~!@#$%^&*()+{}|:\"<>?,./;'[]\\-="); // end of word bool hasModifier = (event->modifiers() != Qt::NoModifier) && !ctrlOrShift; QString completionPrefix = textUnderCursor(); /*QMessageBox::information(this, "", tr("completionPrefix=%1\nisShortcut=%2\nctrlOrShif=%3\nhasModifier=%4") .arg(completionPrefix) .arg(isShortcut) .arg(ctrlOrShift) .arg(hasModifier) );*/ if (!isShortcut && (hasModifier || event->text().isEmpty()|| completionPrefix.length() < 2 || eow.contains(event->text().right(1)))) { c->popup()->hide(); return; } /*QMessageBox::information(this, "", tr("c->completionPrefix=%1\ncompletionPrefix=%2") .arg(c->completionPrefix()) .arg(completionPrefix) );*/ if (completionPrefix != c->completionPrefix()) { c->setCompletionPrefix(completionPrefix); /*QMessageBox::information(this, "", tr("c->completionModel()->rowCount()=%1") .arg(c->completionModel()->rowCount()) );*/ c->popup()->setCurrentIndex(c->completionModel()->index(0, 0)); } QRect cr = cursorRect(); cr.setWidth(c->popup()->sizeHintForColumn(0) + c->popup()->verticalScrollBar()->sizeHint().width()); c->complete(cr); // popup it up! /*QMessageBox::information(this, "", tr("cr.width=%1\ncr.height=%2\ncr.x=%3\ncr.y=%4") .arg(cr.width()) .arg(cr.height()) .arg(cr.x()) .arg(cr.y()) );*/ }
void GenericCodeEditor::keyPressEvent(QKeyEvent * e) { hideMouseCursor(e); QTextCursor cursor( textCursor() ); bool updateCursor = false; if (e == QKeySequence::InsertLineSeparator) { // override to avoid entering a "soft" new line cursor.insertBlock(); updateCursor = true; } else { switch (e->key()) { case Qt::Key_Delete: if (e->modifiers() & Qt::META) { cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor); cursor.removeSelectedText(); } else QPlainTextEdit::keyPressEvent(e); break; case Qt::Key_Backspace: if (e->modifiers() & Qt::META) { cursor.movePosition(QTextCursor::StartOfBlock, QTextCursor::KeepAnchor); cursor.removeSelectedText(); } else { if ( !overwriteMode() || (cursor.positionInBlock() == 0) || cursor.hasSelection() ) { QPlainTextEdit::keyPressEvent(e); } else { // in overwrite mode, backspace should insert a space cursor.movePosition(QTextCursor::PreviousCharacter, QTextCursor::KeepAnchor); QString selectedText = cursor.selectedText(); if (selectedText == QString(" ") || selectedText == QString("\t") ) { cursor.clearSelection(); } else { cursor.insertText(QString(QChar(' '))); cursor.movePosition(QTextCursor::PreviousCharacter); } } updateCursor = true; } break; case Qt::Key_Down: { if (cursor.block() == textDocument()->lastBlock()) { QTextCursor::MoveMode moveMode = e->modifiers() & Qt::SHIFT ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor; cursor.movePosition(QTextCursor::EndOfBlock, moveMode); setTextCursor(cursor); } else QPlainTextEdit::keyPressEvent(e); break; } case Qt::Key_Up: { if (cursor.block() == textDocument()->firstBlock()) { QTextCursor::MoveMode moveMode = e->modifiers() & Qt::SHIFT ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor; cursor.movePosition(QTextCursor::StartOfBlock, moveMode); setTextCursor(cursor); } else QPlainTextEdit::keyPressEvent(e); break; } default: QPlainTextEdit::keyPressEvent(e); } } // else... if (updateCursor) { cursor.setVerticalMovementX(-1); setTextCursor( cursor ); ensureCursorVisible(); } doKeyAction(e); }
void GenericCodeEditor::keyPressEvent(QKeyEvent * e) { hideMouseCursor(e); QTextCursor cursor( textCursor() ); switch (e->key()) { case Qt::Key_Enter: case Qt::Key_Return: // override to avoid entering a "soft" new line when certain modifier is held cursor.insertBlock(); break; case Qt::Key_Delete: if (e->modifiers() & Qt::META) { cursor.movePosition(QTextCursor::EndOfBlock, QTextCursor::KeepAnchor); cursor.removeSelectedText(); } else QPlainTextEdit::keyPressEvent(e); break; case Qt::Key_Backspace: if (e->modifiers() & Qt::META) { cursor.movePosition(QTextCursor::StartOfBlock, QTextCursor::KeepAnchor); cursor.removeSelectedText(); } else QPlainTextEdit::keyPressEvent(e); break; case Qt::Key_Down: { if (cursor.block() == textDocument()->lastBlock()) { QTextCursor::MoveMode moveMode = e->modifiers() & Qt::SHIFT ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor; cursor.movePosition(QTextCursor::EndOfBlock, moveMode); setTextCursor(cursor); } else QPlainTextEdit::keyPressEvent(e); break; } case Qt::Key_Up: { if (cursor.block() == textDocument()->firstBlock()) { QTextCursor::MoveMode moveMode = e->modifiers() & Qt::SHIFT ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor; cursor.movePosition(QTextCursor::StartOfBlock, moveMode); setTextCursor(cursor); } else QPlainTextEdit::keyPressEvent(e); break; } default: QPlainTextEdit::keyPressEvent(e); } switch (e->key()) { case Qt::Key_Enter: case Qt::Key_Return: case Qt::Key_Backspace: cursor.setVerticalMovementX(-1); setTextCursor( cursor ); ensureCursorVisible(); break; default:; } }
void ScCodeEditor::toggleCommentSelection() { QTextCursor cursor = textCursor(); cursor.beginEditBlock(); if (isBlockOnlySelection(cursor)) { const bool isComment = isSingleLineComment(cursor); QTextCursor selectionCursor(cursor); selectionCursor.setPosition(cursor.selectionStart()); QTextBlock currentBlock = selectionCursor.block(); int firstBlockIndentation = isComment ? 0 : indentationLevel(selectionCursor); do { QTextCursor blockCursor(currentBlock); if (!isComment) addSingleLineComment(blockCursor, firstBlockIndentation); else removeSingleLineComment(blockCursor); currentBlock = currentBlock.next(); } while (currentBlock.isValid() && currentBlock.position() < cursor.selectionEnd()); if (!isComment) { // fix up selection QTextCursor newSelection(cursor); if (cursor.anchor() < cursor.position()) { newSelection.setPosition(newSelection.selectionStart()); newSelection.movePosition(QTextCursor::StartOfBlock); newSelection.setPosition(cursor.selectionEnd(), QTextCursor::KeepAnchor); } else { newSelection.setPosition(newSelection.selectionEnd()); newSelection.setPosition(cursor.selectionStart(), QTextCursor::KeepAnchor); newSelection.movePosition(QTextCursor::StartOfBlock, QTextCursor::KeepAnchor); } setTextCursor(newSelection); } } else { QString selectionText = cursor.selectedText(); QTextCursor selectionCursor(cursor); if (isSelectionComment(selectionText)) { selectionText = selectionText.trimmed().remove(0, 2); selectionText.chop(2); selectionCursor.insertText(selectionText); } else { selectionText = QString("/*") + selectionText + QString("*/"); selectionCursor.insertText(selectionText); } // fix up selection const int position = selectionCursor.position(); const int anchor = selectionCursor.anchor(); if (position > anchor) { cursor.setPosition(position - selectionText.size()); cursor.setPosition(position, QTextCursor::KeepAnchor); } else { cursor.setPosition(position); cursor.setPosition(position - selectionText.size(), QTextCursor::KeepAnchor); } setTextCursor(cursor); } cursor.endEditBlock(); }
bool ScCodeEditor::insertMatchingTokens( const QString & text ) { if (text.isEmpty()) return false; QTextCursor cursor = textCursor(); QTextDocument *document = cursor.document(); int cursorPosition = cursor.position(); QChar token = text[0]; QChar matchingToken; static QString openingTokens("([{'\""); static QString closingTokens(")]}'\""); bool isOpeningToken, isClosingToken; int idx; if ( (idx = openingTokens.indexOf(token)) != -1 ) { matchingToken = closingTokens[idx]; isOpeningToken = true; isClosingToken = token == matchingToken; } else if ( (idx = closingTokens.indexOf(token)) != -1 ) { matchingToken = openingTokens[idx]; isClosingToken = true; isOpeningToken = token == matchingToken; } else return false; cursor.beginEditBlock(); if (mInsertMatchingTokens) { if (cursor.hasSelection()) { if (isOpeningToken) { int start = cursor.selectionStart(); int end = cursor.selectionEnd(); cursor.setPosition(start); cursor.insertText(token); cursor.setPosition(end + 1); cursor.insertText(matchingToken); } else cursor.insertText(token); } else { if (isClosingToken && document->characterAt(cursorPosition) == token) { cursor.movePosition(QTextCursor::NextCharacter); } else if (isOpeningToken) { cursor.insertText(token); cursor.insertText(matchingToken); cursor.movePosition(QTextCursor::PreviousCharacter); } else cursor.insertText(token); } } else cursor.insertText(token); cursor.endEditBlock(); cursor.setVerticalMovementX(-1); setTextCursor(cursor); if (isClosingToken) indent(cursor, JoinEditBlock); ensureCursorVisible(); return true; }
void ScCodeEditor::keyPressEvent( QKeyEvent *e ) { hideMouseCursor(e); QTextCursor cursor( textCursor() ); bool cursorMoved = true; if (e == QKeySequence::MoveToNextWord) moveToNextToken( cursor, QTextCursor::MoveAnchor ); else if (e == QKeySequence::MoveToPreviousWord) moveToPreviousToken( cursor, QTextCursor::MoveAnchor ); else if (e == QKeySequence::SelectNextWord) moveToNextToken( cursor, QTextCursor::KeepAnchor ); else if (e == QKeySequence::SelectPreviousWord) moveToPreviousToken( cursor, QTextCursor::KeepAnchor ); else cursorMoved = false; if (cursorMoved) { setTextCursor( cursor ); return; } switch (e->key()) { case Qt::Key_Home: { Qt::KeyboardModifiers mods(e->modifiers()); if (mods && mods != Qt::ShiftModifier) { GenericCodeEditor::keyPressEvent(e); return; } QTextCursor::MoveMode mode = mods & Qt::ShiftModifier ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor; QTextCursor c(textCursor()); QTextBlock b(c.block()); int pos = indentedStartOfLine(b); pos += b.position(); if (c.position() == pos) c.movePosition(QTextCursor::StartOfLine, mode); else c.setPosition(pos, mode); setTextCursor(c); return; } case Qt::Key_Backtab: { QTextCursor cursor = textCursor(); insertSpaceToNextTabStop( cursor ); ensureCursorVisible(); return; } case Qt::Key_Backspace: if (mInsertMatchingTokens && !overwriteMode() && e->modifiers() == 0) if (removeMatchingTokens()) break; GenericCodeEditor::keyPressEvent(e); break; case Qt::Key_Enter: case Qt::Key_Return: { QTextBlock cursorBlock = cursor.block(); int cursorPosInBlock = cursor.position() - cursorBlock.position(); TokenIterator nextToken = TokenIterator::rightOf(cursorBlock, cursorPosInBlock); if ( nextToken.block() == cursorBlock && nextToken.type() == Token::ClosingBracket ) { cursor.beginEditBlock(); cursor.insertBlock(); cursor.insertBlock(); cursor.endEditBlock(); cursor.movePosition( QTextCursor::PreviousBlock, QTextCursor::KeepAnchor ); indent(cursor, JoinEditBlock); cursor.movePosition( QTextCursor::EndOfBlock ); } else { cursor.beginEditBlock(); cursor.insertBlock(); cursor.endEditBlock(); indent(cursor, JoinEditBlock); } cursor.setVerticalMovementX(-1); setTextCursor(cursor); break; } default: if (!overwriteMode() && insertMatchingTokens(e->text())) break; GenericCodeEditor::keyPressEvent(e); } mAutoCompleter->keyPress(e); }
bool SourceViewerWidget::findText(const QString &text, WebWidget::FindFlags flags) { const bool isTheSame(text == m_findText); m_findText = text; m_findFlags = flags; if (!text.isEmpty()) { QTextDocument::FindFlags nativeFlags; if (flags.testFlag(WebWidget::BackwardFind)) { nativeFlags |= QTextDocument::FindBackward; } if (flags.testFlag(WebWidget::CaseSensitiveFind)) { nativeFlags |= QTextDocument::FindCaseSensitively; } QTextCursor findTextCursor(m_findTextAnchor); if (!isTheSame) { findTextCursor = textCursor(); } else if (!flags.testFlag(WebWidget::BackwardFind)) { findTextCursor.setPosition(findTextCursor.selectionEnd(), QTextCursor::MoveAnchor); } m_findTextAnchor = document()->find(text, findTextCursor, nativeFlags); if (m_findTextAnchor.isNull()) { m_findTextAnchor = textCursor(); m_findTextAnchor.setPosition((flags.testFlag(WebWidget::BackwardFind) ? (document()->characterCount() - 1) : 0), QTextCursor::MoveAnchor); m_findTextAnchor = document()->find(text, m_findTextAnchor, nativeFlags); } if (!m_findTextAnchor.isNull()) { const QTextCursor currentTextCursor(textCursor()); disconnect(this, SIGNAL(cursorPositionChanged()), this, SLOT(updateTextCursor())); setTextCursor(m_findTextAnchor); ensureCursorVisible(); const QPoint position(horizontalScrollBar()->value(), verticalScrollBar()->value()); setTextCursor(currentTextCursor); horizontalScrollBar()->setValue(position.x()); verticalScrollBar()->setValue(position.y()); connect(this, SIGNAL(cursorPositionChanged()), this, SLOT(updateTextCursor())); } } m_findTextSelection = m_findTextAnchor; updateSelection(); return !m_findTextAnchor.isNull(); }
bool QFCompleterTextEditWidget::replaceFirst(QString phrase, QString replaceBy, bool searchFromStart, bool matchCase, bool wholeWords, bool replaceAll, bool askBeforeReplace){ this->searchFromStart=searchFromStart; this->matchCase=matchCase; this->wholeWords=wholeWords; this->searchPhrase=phrase; this->replacePhrase=replaceBy; this->replaceAll=replaceAll; this->askBeforeReplace=askBeforeReplace; currentlySearching=false; currentlyReplacing=true; emit findNextAvailable(true); QTextCursor c(textCursor()); c.clearSelection(); if (searchFromStart) { c.movePosition(QTextCursor::StartOfLine, QTextCursor::MoveAnchor); while (!c.atStart()) { c.movePosition(QTextCursor::Up, QTextCursor::MoveAnchor); } } setTextCursor(c); // find the next occurence QTextDocument::FindFlags flags=0; if (matchCase) flags |= QTextDocument::FindCaseSensitively; if (wholeWords) flags |= QTextDocument::FindWholeWords; if (replaceAll) { long count=0; bool stopped=false; while (find(phrase, flags) && !stopped) { if (askBeforeReplace) { QMessageBox::StandardButton ret; ret = QMessageBox::question(this, tr("Find & Replace ..."), tr("Replace this occurence?"), QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel); if (ret == QMessageBox::Cancel) { stopped=true; } else if (ret == QMessageBox::Yes) { QTextCursor c(textCursor()); c.insertText(replacePhrase); setTextCursor(c); count++; } } else { QTextCursor c(textCursor()); c.insertText(replacePhrase); setTextCursor(c); count++; } } if (count>0) QMessageBox::information(this, tr("Find & Replace ..."), tr("Replaced %1 occurences of '%2' ...") .arg(count) .arg(searchPhrase)); emit findNextAvailable(false); return (count>0); } else { if (!find(searchPhrase, flags)) { /*QMessageBox::information(this, tr("Find & Replace ..."), tr("Did not find '%1' ...") .arg(searchPhrase));*/ emit findNextAvailable(false); return false; } else { if (askBeforeReplace) { QMessageBox::StandardButton ret; ret = QMessageBox::question(this, tr("Find & Replace ..."), tr("Replace this occurence?"), QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel); if (ret == QMessageBox::Cancel) { emit findNextAvailable(false); return true; } else if (ret == QMessageBox::Yes) { QTextCursor c(textCursor()); c.insertText(replacePhrase); setTextCursor(c); emit findNextAvailable(true); return true; } else if (ret == QMessageBox::No) { emit findNextAvailable(true); return true; } } else { QTextCursor c(textCursor()); c.insertText(replacePhrase); setTextCursor(c); emit findNextAvailable(true); return true; } } } emit findNextAvailable(false); return false; }
void GroupedLineEdit::setCursorPosition(int position) { QTextCursor c = textCursor(); c.setPosition(position, QTextCursor::MoveAnchor); setTextCursor(c); }
bool ChatTextEdit::eventFilter(QObject *obj, QEvent *event) { if (event->type() == QEvent::KeyPress) { QKeyEvent *keyEvent = (QKeyEvent *) event; if (keyEvent->key() == Qt::Key_Up) { // Key up QTextCursor cursor = textCursor(); int pos = cursor.position(); bool sel = keyEvent->modifiers() == Qt::ShiftModifier; cursor.movePosition(QTextCursor::Up, (sel ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor)); if (pos == cursor.position()) cursor.movePosition(QTextCursor::Start, (sel ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor)); setTextCursor(cursor); return true; } else if (keyEvent->key() == Qt::Key_Down) { // Key down QTextCursor cursor = textCursor(); int pos = cursor.position(); bool sel = keyEvent->modifiers() == Qt::ShiftModifier; cursor.movePosition(QTextCursor::Down, (sel ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor)); if (pos == cursor.position()) cursor.movePosition(QTextCursor::End, (sel ? QTextCursor::KeepAnchor : QTextCursor::MoveAnchor)); setTextCursor(cursor); return true; } else if (keyEvent->nativeScanCode() == 36) { // Return pressed if (Client::enterIsSend && !(keyEvent->modifiers() & Qt::ShiftModifier)) { isComposing = false; emit returnPressed(); return true; } } else if (keyEvent->nativeScanCode() == 54 && keyEvent->modifiers() == Qt::ControlModifier) { // Copy QTextCursor cursor = textCursor(); if (cursor.hasSelection()) { QTextDocumentFragment selection = cursor.selection(); QClipboard *clipboard = QApplication::clipboard(); clipboard->setText(Utilities::htmlToWAText(selection.toHtml())); QMaemo5InformationBox::information(this,"Copied"); return true; } } else if (keyEvent->nativeScanCode() == 55 && keyEvent->modifiers() == Qt::ControlModifier) { // Paste event QTextCursor cursor = textCursor(); QClipboard *clipboard = QApplication::clipboard(); cursor.insertHtml(Utilities::WATextToHtml(clipboard->text(),32,false)); return true; } else if (!isComposing) { isComposing = true; emit composing(); } else { lastKeyPressed = QDateTime::currentMSecsSinceEpoch(); composingTimer.start(2000); } } else if (event->type() == QEvent::InputMethod) { QInputMethodEvent *inputEvent = (QInputMethodEvent *) event; //Utilities::logData("Commit String: '" + inputEvent->commitString() + "'"); if (inputEvent->commitString() == "\n" && Client::enterIsSend) { // Let's hide the keyboard if it was shown QTimer::singleShot(0,this,SLOT(closeKB())); isComposing = false; emit returnPressed(); return true; } } return QTextEdit::eventFilter(obj,event); }
void CodeArea::keyPressEvent(QKeyEvent *e) { if (mCompleter && mCompleter->popup()->isVisible()) { // The following keys are forwarded by the completer to the widget switch (e->key()) { case Qt::Key_Enter: case Qt::Key_Return: case Qt::Key_Escape: case Qt::Key_Tab: case Qt::Key_Backtab: e->ignore(); return; // let the completer do default behavior default: break; } } { switch (e->key()) { case Qt::Key_Tab: { QTextCursor tc = textCursor(); if(tc.hasSelection()) { } if(!(e->modifiers() & (Qt::ShiftModifier | Qt::ControlModifier))) { this->insertPlainText(" "); QTextCursor tc = textCursor(); tc.setPosition(tc.position()); setTextCursor(tc); return; } } case Qt::Key_Backtab: { QTextCursor tc = textCursor(); QTextBlock tb = tc.block(); QString str = tb.text(); int space = 4; tc.movePosition(QTextCursor::StartOfLine); foreach(QString s, str) { if(s == " "&& space!=0) { space--; tc.movePosition(QTextCursor::Right); tc.deletePreviousChar(); } else break; } return; } case Qt::Key_Return: { QTextCursor tc = textCursor(); QTextBlock tb = tc.block(); QString str = tb.text(); int space = 0; foreach(QString s, str) { if(s == " ") space++; else break; } insertPlainText("\n"); for(int x= 0; x <space;++x) insertPlainText(" "); tc.movePosition(QTextCursor::EndOfLine); setTextCursor(tc); e->accept(); return; } default: break; } } bool isShortcut = ((e->modifiers() & Qt::ControlModifier) && e->key() == Qt::Key_Space); // CTRL+E if (!mCompleter || !isShortcut) // do not process the shortcut when we have a completer QPlainTextEdit::keyPressEvent(e); const bool ctrlOrShift = e->modifiers() & (Qt::ControlModifier | Qt::ShiftModifier); if (!mCompleter || (ctrlOrShift && e->text().isEmpty())) return; static QString eow("~!@#$%^&*_+(){}|\"<>?,:./;'[]\\-="); // end of word bool hasModifier = (e->modifiers() != Qt::NoModifier) && !ctrlOrShift; QString completionPrefix = textUnderCursor(); /*if(completionPrefix.endsWith(")")) { completionPrefix.remove(completionPrefix.size()-1); }*/ if (!isShortcut && (hasModifier || e->text().isEmpty()|| completionPrefix.length() < 3 || eow.contains(e->text().right(1)))) { mCompleter->popup()->hide(); return; } if (completionPrefix != mCompleter->completionPrefix()) { mCompleter->setCompletionPrefix(completionPrefix); mCompleter->popup()->setCurrentIndex(mCompleter->completionModel()->index(0, 0)); } QRect cr = cursorRect(); cr.setWidth(mCompleter->popup()->sizeHintForColumn(0) + mCompleter->popup()->verticalScrollBar()->sizeHint().width()); mCompleter->complete(cr); // popup it up! }
void ScCodeEditor::selectBlockAroundCursor() { QTextCursor block_cursor = blockAroundCursor(textCursor()); if (!block_cursor.isNull()) setTextCursor(block_cursor); }