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);
}
