void GenericCodeEditor::handleKeyBackspace(QKeyEvent * event, QTextCursor & textCursor, bool & updateCursor)
{
if (event->modifiers() & Qt::META) {
textCursor.movePosition(QTextCursor::StartOfBlock, QTextCursor::KeepAnchor);
textCursor.removeSelectedText();
} else {
if ( !overwriteMode()
|| (textCursor.positionInBlock() == 0)
|| textCursor.hasSelection() ) {
QPlainTextEdit::keyPressEvent(event);
} else {
// in overwrite mode, backspace should insert a space
textCursor.beginEditBlock();
textCursor.movePosition(QTextCursor::PreviousCharacter, QTextCursor::KeepAnchor);
QString selectedText = textCursor.selectedText();
if (selectedText == QStringLiteral(" ") ||
selectedText == QStringLiteral("\t") ) {
textCursor.clearSelection();
} else {
textCursor.insertText(QString(QChar(' ')));
textCursor.movePosition(QTextCursor::PreviousCharacter);
}
textCursor.endEditBlock();
}
updateCursor = true;
}
}
void GenericCodeEditor::toggleOverwriteMode()
{
setOverwriteMode(!overwriteMode());
// FIXME: reset cursor to the same position in to force a repaint
// there might be a nicer solution for this issue, though
setTextCursor(textCursor());
}
int QHexEdit::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QScrollArea::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: currentAddressChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
case 1: currentSizeChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
case 2: dataChanged(); break;
case 3: overwriteModeChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 4: setAddressWidth((*reinterpret_cast< int(*)>(_a[1]))); break;
case 5: setAddressArea((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 6: setAsciiArea((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 7: setHighlighting((*reinterpret_cast< bool(*)>(_a[1]))); break;
default: ;
}
_id -= 8;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QByteArray*>(_v) = data(); break;
case 1: *reinterpret_cast< int*>(_v) = addressOffset(); break;
case 2: *reinterpret_cast< QColor*>(_v) = addressAreaColor(); break;
case 3: *reinterpret_cast< QColor*>(_v) = highlightingColor(); break;
case 4: *reinterpret_cast< bool*>(_v) = overwriteMode(); break;
}
_id -= 5;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setData(*reinterpret_cast< QByteArray*>(_v)); break;
case 1: setAddressOffset(*reinterpret_cast< int*>(_v)); break;
case 2: setAddressAreaColor(*reinterpret_cast< QColor*>(_v)); break;
case 3: setHighlightingColor(*reinterpret_cast< QColor*>(_v)); break;
case 4: setOverwriteMode(*reinterpret_cast< bool*>(_v)); break;
}
_id -= 5;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 5;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 5;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 5;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 5;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 5;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 5;
}
#endif // QT_NO_PROPERTIES
return _id;
}
void QScintillaWidget::updateUi()
{
// Update our editing mode, if needed
bool newInsertMode = !overwriteMode();
if ( (newInsertMode != mInsertMode)
|| mEditingModeWidget->text().isEmpty()) {
mInsertMode = newInsertMode;
mEditingModeWidget->setText(mInsertMode?"INS":"OVR");
}
}
int QTextControl::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 38)
qt_static_metacall(this, _c, _id, _a);
_id -= 38;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< QString*>(_v) = toHtml(); break;
case 1: *reinterpret_cast< bool*>(_v) = overwriteMode(); break;
case 2: *reinterpret_cast< bool*>(_v) = acceptRichText(); break;
case 3: *reinterpret_cast< int*>(_v) = cursorWidth(); break;
case 4: *reinterpret_cast< Qt::TextInteractionFlags*>(_v) = textInteractionFlags(); break;
case 5: *reinterpret_cast< bool*>(_v) = openExternalLinks(); break;
case 6: *reinterpret_cast< bool*>(_v) = ignoreUnusedNavigationEvents(); break;
}
_id -= 7;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: setHtml(*reinterpret_cast< QString*>(_v)); break;
case 1: setOverwriteMode(*reinterpret_cast< bool*>(_v)); break;
case 2: setAcceptRichText(*reinterpret_cast< bool*>(_v)); break;
case 3: setCursorWidth(*reinterpret_cast< int*>(_v)); break;
case 4: setTextInteractionFlags(*reinterpret_cast< Qt::TextInteractionFlags*>(_v)); break;
case 5: setOpenExternalLinks(*reinterpret_cast< bool*>(_v)); break;
case 6: setIgnoreUnusedNavigationEvents(*reinterpret_cast< bool*>(_v)); break;
}
_id -= 7;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 7;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 7;
}
#endif // QT_NO_PROPERTIES
return _id;
}
void GenericCodeEditor::toggleOverwriteMode()
{
setOverwriteMode(!overwriteMode());
}
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);
}
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);
}
// ********************************************************************** Handle events
void QHexEdit::keyPressEvent(QKeyEvent *event)
{
// Cursor movements
if (event->matches(QKeySequence::MoveToNextChar))
{
setCursorPosition(_cursorPosition + 1);
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToPreviousChar))
{
setCursorPosition(_cursorPosition - 1);
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToEndOfLine))
{
setCursorPosition(_cursorPosition | (2 * BYTES_PER_LINE -1));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToStartOfLine))
{
setCursorPosition(_cursorPosition - (_cursorPosition % (2 * BYTES_PER_LINE)));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToPreviousLine))
{
setCursorPosition(_cursorPosition - (2 * BYTES_PER_LINE));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToNextLine))
{
setCursorPosition(_cursorPosition + (2 * BYTES_PER_LINE));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToNextPage))
{
setCursorPosition(_cursorPosition + (((_rowsShown - 1) * 2 * BYTES_PER_LINE)));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToPreviousPage))
{
setCursorPosition(_cursorPosition - (((_rowsShown - 1) * 2 * BYTES_PER_LINE)));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToEndOfDocument))
{
setCursorPosition(_chunks->size() * 2);
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToStartOfDocument))
{
setCursorPosition(0);
resetSelection(_cursorPosition);
}
// Select commands
if (event->matches(QKeySequence::SelectAll))
{
resetSelection(0);
setSelection(2*_chunks->size() + 1);
}
if (event->matches(QKeySequence::SelectNextChar))
{
qint64 pos = _cursorPosition + 1;
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectPreviousChar))
{
qint64 pos = _cursorPosition - 1;
setSelection(pos);
setCursorPosition(pos);
}
if (event->matches(QKeySequence::SelectEndOfLine))
{
qint64 pos = _cursorPosition - (_cursorPosition % (2 * BYTES_PER_LINE)) + (2 * BYTES_PER_LINE);
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectStartOfLine))
{
qint64 pos = _cursorPosition - (_cursorPosition % (2 * BYTES_PER_LINE));
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectPreviousLine))
{
qint64 pos = _cursorPosition - (2 * BYTES_PER_LINE);
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectNextLine))
{
qint64 pos = _cursorPosition + (2 * BYTES_PER_LINE);
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectNextPage))
{
qint64 pos = _cursorPosition + (((viewport()->height() / _pxCharHeight) - 1) * 2 * BYTES_PER_LINE);
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectPreviousPage))
{
qint64 pos = _cursorPosition - (((viewport()->height() / _pxCharHeight) - 1) * 2 * BYTES_PER_LINE);
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectEndOfDocument))
{
qint64 pos = _chunks->size() * 2;
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectStartOfDocument))
{
qint64 pos = 0;
setCursorPosition(pos);
setSelection(pos);
}
// Edit Commands
if (!_readOnly)
{
if ((QApplication::keyboardModifiers() == Qt::NoModifier) ||
(QApplication::keyboardModifiers() == Qt::KeypadModifier))
{
/* Hex input */
int key = int(event->text()[0].toLatin1());
if ((key>='0' && key<='9') || (key>='a' && key <= 'f'))
{
if (getSelectionBegin() != getSelectionEnd())
{
if (_overwriteMode)
{
qint64 len = getSelectionEnd() - getSelectionBegin();
replace(getSelectionBegin(), (int)len, QByteArray((int)len, char(0)));
}
else
{
remove(getSelectionBegin(), getSelectionEnd() - getSelectionBegin());
_bPosCurrent = getSelectionBegin();
}
setCursorPosition(2*_bPosCurrent);
resetSelection(2*_bPosCurrent);
}
// If insert mode, then insert a byte
if (_overwriteMode == false)
if ((_cursorPosition % 2) == 0)
insert(_bPosCurrent, char(0));
// Change content
if (_chunks->size() > 0)
{
QByteArray hexValue = _chunks->data(_bPosCurrent, 1).toHex();
if ((_cursorPosition % 2) == 0)
hexValue[0] = key;
else
hexValue[1] = key;
replace(_bPosCurrent, QByteArray().fromHex(hexValue)[0]);
setCursorPosition(_cursorPosition + 1);
resetSelection(_cursorPosition);
}
}
}
/* Cut */
if (event->matches(QKeySequence::Cut))
{
QByteArray ba = _chunks->data(getSelectionBegin(), getSelectionEnd() - getSelectionBegin()).toHex();
for (qint64 idx = 32; idx < ba.size(); idx +=33)
ba.insert(idx, "\n");
QClipboard *clipboard = QApplication::clipboard();
clipboard->setText(ba);
if (_overwriteMode)
{
qint64 len = getSelectionEnd() - getSelectionBegin();
replace(getSelectionBegin(), (int)len, QByteArray((int)len, char(0)));
}
else
{
remove(getSelectionBegin(), getSelectionEnd() - getSelectionBegin());
}
setCursorPosition(2*getSelectionBegin());
resetSelection(2*getSelectionBegin());
}
/* Paste */
if (event->matches(QKeySequence::Paste))
{
QClipboard *clipboard = QApplication::clipboard();
QByteArray ba = QByteArray().fromHex(clipboard->text().toLatin1());
if (_overwriteMode)
replace(_bPosCurrent, ba.size(), ba);
else
insert(_bPosCurrent, ba);
setCursorPosition(_cursorPosition + 2 * ba.size());
resetSelection(getSelectionBegin());
}
/* Delete char */
if (event->matches(QKeySequence::Delete))
{
if (getSelectionBegin() != getSelectionEnd())
{
_bPosCurrent = getSelectionBegin();
if (_overwriteMode)
{
QByteArray ba = QByteArray(getSelectionEnd() - getSelectionBegin(), char(0));
replace(_bPosCurrent, ba.size(), ba);
}
else
{
remove(_bPosCurrent, getSelectionEnd() - getSelectionBegin());
}
}
else
{
if (_overwriteMode)
replace(_bPosCurrent, char(0));
else
remove(_bPosCurrent, 1);
}
setCursorPosition(2 * _bPosCurrent);
resetSelection(2 * _bPosCurrent);
}
/* Backspace */
if ((event->key() == Qt::Key_Backspace) && (event->modifiers() == Qt::NoModifier))
{
if (getSelectionBegin() != getSelectionEnd())
{
_bPosCurrent = getSelectionBegin();
setCursorPosition(2 * _bPosCurrent);
if (_overwriteMode)
{
QByteArray ba = QByteArray(getSelectionEnd() - getSelectionBegin(), char(0));
replace(_bPosCurrent, ba.size(), ba);
}
else
{
remove(_bPosCurrent, getSelectionEnd() - getSelectionBegin());
}
resetSelection(2 * _bPosCurrent);
}
else
{
bool behindLastByte = false;
if ((_cursorPosition / 2) == _chunks->size())
behindLastByte = true;
_bPosCurrent -= 1;
if (_overwriteMode)
replace(_bPosCurrent, char(0));
else
remove(_bPosCurrent, 1);
if (!behindLastByte)
_bPosCurrent -= 1;
setCursorPosition(2 * _bPosCurrent);
resetSelection(2 * _bPosCurrent);
}
}
/* undo */
if (event->matches(QKeySequence::Undo))
{
undo();
}
/* redo */
if (event->matches(QKeySequence::Redo))
{
redo();
}
}
/* Copy */
if (event->matches(QKeySequence::Copy))
{
QByteArray ba = _chunks->data(getSelectionBegin(), getSelectionEnd() - getSelectionBegin()).toHex();
for (qint64 idx = 32; idx < ba.size(); idx +=33)
ba.insert(idx, "\n");
QClipboard *clipboard = QApplication::clipboard();
clipboard->setText(ba);
}
// Switch between insert/overwrite mode
if ((event->key() == Qt::Key_Insert) && (event->modifiers() == Qt::NoModifier))
{
setOverwriteMode(!overwriteMode());
setCursorPosition(_cursorPosition);
}
// Refresh Event
if ((event->key() == Qt::Key_F5))
executableViewer->getMainWindow()->refresh();
refresh();
}
int QPlainTextEdit::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QAbstractScrollArea::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 25)
qt_static_metacall(this, _c, _id, _a);
_id -= 25;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0:
*reinterpret_cast< bool*>(_v) = tabChangesFocus();
break;
case 1:
*reinterpret_cast< QString*>(_v) = documentTitle();
break;
case 2:
*reinterpret_cast< bool*>(_v) = isUndoRedoEnabled();
break;
case 3:
*reinterpret_cast< LineWrapMode*>(_v) = lineWrapMode();
break;
case 4:
*reinterpret_cast< bool*>(_v) = isReadOnly();
break;
case 5:
*reinterpret_cast< QString*>(_v) = toPlainText();
break;
case 6:
*reinterpret_cast< bool*>(_v) = overwriteMode();
break;
case 7:
*reinterpret_cast< int*>(_v) = tabStopWidth();
break;
case 8:
*reinterpret_cast< int*>(_v) = cursorWidth();
break;
case 9:
*reinterpret_cast< Qt::TextInteractionFlags*>(_v) = textInteractionFlags();
break;
case 10:
*reinterpret_cast< int*>(_v) = blockCount();
break;
case 11:
*reinterpret_cast< int*>(_v) = maximumBlockCount();
break;
case 12:
*reinterpret_cast< bool*>(_v) = backgroundVisible();
break;
case 13:
*reinterpret_cast< bool*>(_v) = centerOnScroll();
break;
}
_id -= 14;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0:
setTabChangesFocus(*reinterpret_cast< bool*>(_v));
break;
case 1:
setDocumentTitle(*reinterpret_cast< QString*>(_v));
break;
case 2:
setUndoRedoEnabled(*reinterpret_cast< bool*>(_v));
break;
case 3:
setLineWrapMode(*reinterpret_cast< LineWrapMode*>(_v));
break;
case 4:
setReadOnly(*reinterpret_cast< bool*>(_v));
break;
case 5:
setPlainText(*reinterpret_cast< QString*>(_v));
break;
case 6:
setOverwriteMode(*reinterpret_cast< bool*>(_v));
break;
case 7:
setTabStopWidth(*reinterpret_cast< int*>(_v));
break;
case 8:
setCursorWidth(*reinterpret_cast< int*>(_v));
break;
case 9:
setTextInteractionFlags(*reinterpret_cast< Qt::TextInteractionFlags*>(_v));
break;
case 11:
setMaximumBlockCount(*reinterpret_cast< int*>(_v));
break;
case 12:
setBackgroundVisible(*reinterpret_cast< bool*>(_v));
break;
case 13:
setCenterOnScroll(*reinterpret_cast< bool*>(_v));
break;
}
_id -= 14;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 14;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 14;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 14;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 14;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 14;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 14;
}
#endif // QT_NO_PROPERTIES
return _id;
}
// ********************************************************************** Handle events
void QHexEdit::keyPressEvent(QKeyEvent *event)
{
// Cursor movements
if (event->matches(QKeySequence::MoveToNextChar))
{
qint64 pos = _cursorPosition + 1;
if (_editAreaIsAscii)
pos += 1;
setCursorPosition(pos);
resetSelection(pos);
}
if (event->matches(QKeySequence::MoveToPreviousChar))
{
qint64 pos = _cursorPosition - 1;
if (_editAreaIsAscii)
pos -= 1;
setCursorPosition(pos);
resetSelection(pos);
}
if (event->matches(QKeySequence::MoveToEndOfLine))
{
qint64 pos = _cursorPosition - (_cursorPosition % (2 * _bytesPerLine)) + (2 * _bytesPerLine) - 1;
setCursorPosition(pos);
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToStartOfLine))
{
qint64 pos = _cursorPosition - (_cursorPosition % (2 * _bytesPerLine));
setCursorPosition(pos);
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToPreviousLine))
{
setCursorPosition(_cursorPosition - (2 * _bytesPerLine));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToNextLine))
{
setCursorPosition(_cursorPosition + (2 * _bytesPerLine));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToNextPage))
{
setCursorPosition(_cursorPosition + (((_rowsShown - 1) * 2 * _bytesPerLine)));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToPreviousPage))
{
setCursorPosition(_cursorPosition - (((_rowsShown - 1) * 2 * _bytesPerLine)));
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToEndOfDocument))
{
setCursorPosition(_chunks->size() * 2 );
resetSelection(_cursorPosition);
}
if (event->matches(QKeySequence::MoveToStartOfDocument))
{
setCursorPosition(0);
resetSelection(_cursorPosition);
}
// Select commands
if (event->matches(QKeySequence::SelectAll))
{
resetSelection(0);
setSelection(2 * _chunks->size() + 1);
}
if (event->matches(QKeySequence::SelectNextChar))
{
qint64 pos = _cursorPosition + 1;
if (_editAreaIsAscii)
pos += 1;
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectPreviousChar))
{
qint64 pos = _cursorPosition - 1;
if (_editAreaIsAscii)
pos -= 1;
setSelection(pos);
setCursorPosition(pos);
}
if (event->matches(QKeySequence::SelectEndOfLine))
{
qint64 pos = _cursorPosition - (_cursorPosition % (2 * _bytesPerLine)) + (2 * _bytesPerLine) - 1;
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectStartOfLine))
{
qint64 pos = _cursorPosition - (_cursorPosition % (2 * _bytesPerLine));
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectPreviousLine))
{
qint64 pos = _cursorPosition - (2 * _bytesPerLine);
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectNextLine))
{
qint64 pos = _cursorPosition + (2 * _bytesPerLine);
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectNextPage))
{
qint64 pos = _cursorPosition + (((viewport()->height() / _pxCharHeight) - 1) * 2 * _bytesPerLine);
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectPreviousPage))
{
qint64 pos = _cursorPosition - (((viewport()->height() / _pxCharHeight) - 1) * 2 * _bytesPerLine);
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectEndOfDocument))
{
qint64 pos = _chunks->size() * 2;
setCursorPosition(pos);
setSelection(pos);
}
if (event->matches(QKeySequence::SelectStartOfDocument))
{
qint64 pos = 0;
setCursorPosition(pos);
setSelection(pos);
}
// Edit Commands
if (!_readOnly)
{
/* Cut */
if (event->matches(QKeySequence::Cut))
{
QByteArray ba = _chunks->data(getSelectionBegin(), getSelectionEnd() - getSelectionBegin()).toHex();
for (qint64 idx = 32; idx < ba.size(); idx +=33)
ba.insert(idx, "\n");
QClipboard *clipboard = QApplication::clipboard();
clipboard->setText(ba);
if (_overwriteMode)
{
qint64 len = getSelectionEnd() - getSelectionBegin();
replace(getSelectionBegin(), (int)len, QByteArray((int)len, char(0)));
}
else
{
remove(getSelectionBegin(), getSelectionEnd() - getSelectionBegin());
}
setCursorPosition(2 * getSelectionBegin());
resetSelection(2 * getSelectionBegin());
} else
/* Paste */
if (event->matches(QKeySequence::Paste))
{
QClipboard *clipboard = QApplication::clipboard();
QByteArray ba = QByteArray().fromHex(clipboard->text().toLatin1());
if (_overwriteMode)
{
ba = ba.left(std::min<qint64>(ba.size(), (_chunks->size() - _bPosCurrent)));
replace(_bPosCurrent, ba.size(), ba);
}
else
insert(_bPosCurrent, ba);
setCursorPosition(_cursorPosition + 2 * ba.size());
resetSelection(getSelectionBegin());
} else
/* Delete char */
if (event->matches(QKeySequence::Delete))
{
if (getSelectionBegin() != getSelectionEnd())
{
_bPosCurrent = getSelectionBegin();
if (_overwriteMode)
{
QByteArray ba = QByteArray(getSelectionEnd() - getSelectionBegin(), char(0));
replace(_bPosCurrent, ba.size(), ba);
}
else
{
remove(_bPosCurrent, getSelectionEnd() - getSelectionBegin());
}
}
else
{
if (_overwriteMode)
replace(_bPosCurrent, char(0));
else
remove(_bPosCurrent, 1);
}
setCursorPosition(2 * _bPosCurrent);
resetSelection(2 * _bPosCurrent);
} else
/* Backspace */
if ((event->key() == Qt::Key_Backspace) && (event->modifiers() == Qt::NoModifier))
{
if (getSelectionBegin() != getSelectionEnd())
{
_bPosCurrent = getSelectionBegin();
setCursorPosition(2 * _bPosCurrent);
if (_overwriteMode)
{
QByteArray ba = QByteArray(getSelectionEnd() - getSelectionBegin(), char(0));
replace(_bPosCurrent, ba.size(), ba);
}
else
{
remove(_bPosCurrent, getSelectionEnd() - getSelectionBegin());
}
resetSelection(2 * _bPosCurrent);
}
else
{
bool behindLastByte = false;
if ((_cursorPosition / 2) == _chunks->size())
behindLastByte = true;
_bPosCurrent -= 1;
if (_overwriteMode)
replace(_bPosCurrent, char(0));
else
remove(_bPosCurrent, 1);
if (!behindLastByte)
_bPosCurrent -= 1;
setCursorPosition(2 * _bPosCurrent);
resetSelection(2 * _bPosCurrent);
}
} else
/* undo */
if (event->matches(QKeySequence::Undo))
{
undo();
} else
/* redo */
if (event->matches(QKeySequence::Redo))
{
redo();
} else
if ((QApplication::keyboardModifiers() == Qt::NoModifier) ||
(QApplication::keyboardModifiers() == Qt::KeypadModifier) ||
(QApplication::keyboardModifiers() == Qt::ShiftModifier) ||
(QApplication::keyboardModifiers() == (Qt::AltModifier | Qt::ControlModifier)) ||
(QApplication::keyboardModifiers() == Qt::GroupSwitchModifier))
{
/* Hex and ascii input */
int key;
if (_editAreaIsAscii)
key = (uchar)event->text()[0].toLatin1();
else
key = int(event->text()[0].toLower().toLatin1());
if ((((key >= '0' && key <= '9') || (key >= 'a' && key <= 'f')) && _editAreaIsAscii == false)
|| (key >= ' ' && _editAreaIsAscii))
{
if (getSelectionBegin() != getSelectionEnd())
{
if (_overwriteMode)
{
qint64 len = getSelectionEnd() - getSelectionBegin();
replace(getSelectionBegin(), (int)len, QByteArray((int)len, char(0)));
} else
{
remove(getSelectionBegin(), getSelectionEnd() - getSelectionBegin());
_bPosCurrent = getSelectionBegin();
}
setCursorPosition(2 * _bPosCurrent);
resetSelection(2 * _bPosCurrent);
}
// If insert mode, then insert a byte
if (_overwriteMode == false)
if ((_cursorPosition % 2) == 0)
insert(_bPosCurrent, char(0));
// Change content
if (_chunks->size() > 0)
{
char ch = key;
if (!_editAreaIsAscii){
QByteArray hexValue = _chunks->data(_bPosCurrent, 1).toHex();
if ((_cursorPosition % 2) == 0)
hexValue[0] = key;
else
hexValue[1] = key;
ch = QByteArray().fromHex(hexValue)[0];
}
replace(_bPosCurrent, ch);
if (_editAreaIsAscii)
setCursorPosition(_cursorPosition + 2);
else
setCursorPosition(_cursorPosition + 1);
resetSelection(_cursorPosition);
}
}
}
}
/* Copy */
if (event->matches(QKeySequence::Copy))
{
QByteArray ba = _chunks->data(getSelectionBegin(), getSelectionEnd() - getSelectionBegin()).toHex();
for (qint64 idx = 32; idx < ba.size(); idx +=33)
ba.insert(idx, "\n");
QClipboard *clipboard = QApplication::clipboard();
clipboard->setText(ba);
}
// Switch between insert/overwrite mode
if ((event->key() == Qt::Key_Insert) && (event->modifiers() == Qt::NoModifier))
{
setOverwriteMode(!overwriteMode());
setCursorPosition(_cursorPosition);
}
// switch from hex to ascii edit
if (event->key() == Qt::Key_Tab && !_editAreaIsAscii){
_editAreaIsAscii = true;
setCursorPosition(_cursorPosition);
}
// switch from ascii to hex edit
if (event->key() == Qt::Key_Backtab && _editAreaIsAscii){
_editAreaIsAscii = false;
setCursorPosition(_cursorPosition);
}
refresh();
}
bool BatchProcessImagesDialog::startProcess()
{
if (m_convertStatus == STOP_PROCESS)
{
endProcess();
return true;
}
QString targetAlbum = m_ui->m_destinationUrl->url().path();
//TODO check if it is valid also for remote URL's
// this is a workarond for bug 117397
QFileInfo dirInfo(targetAlbum + '/');
if (!dirInfo.isDir() || !dirInfo.isWritable())
{
KMessageBox::error(this, i18n("You must specify a writable path for your output file."));
endProcess();
return true;
}
BatchProcessImagesItem* item = static_cast<BatchProcessImagesItem*>(**m_listFile2Process_iterator);
m_listFiles->setCurrentItem(item);
// Lock current item into KIPI host application
KPFileReadLocker(iface(), item->pathSrc());
if (prepareStartProcess(item, targetAlbum) == false) // If there is a problem during the
{ // preparation -> pass to the next item!
++*m_listFile2Process_iterator;
++m_progressStatus;
m_ui->m_progress->setValue((int)((float)m_progressStatus *(float)100 / (float)m_nbItem));
item = static_cast<BatchProcessImagesItem*>(**m_listFile2Process_iterator);
m_listFiles->setCurrentItem(item);
if (**m_listFile2Process_iterator)
{
startProcess();
return true;
}
else
{
endProcess();
return true;
}
}
KUrl desturl(targetAlbum + '/' + item->nameDest());
if (KIO::NetAccess::exists(desturl, KIO::NetAccess::DestinationSide,
kapp->activeWindow()) == true)
{
switch (overwriteMode())
{
case OVERWRITE_ASK:
{
int ValRet = KMessageBox::warningYesNoCancel(this,
i18n("The destination file \"%1\" already exists;\n"
"do you want overwrite it?", item->nameDest()),
i18n("Overwrite Destination Image File"), KStandardGuiItem::cont());
if (ValRet == KMessageBox::No)
{
item->changeResult(i18n("Skipped."));
item->changeError(i18n("destination image file already exists (skipped by user)."));
++*m_listFile2Process_iterator;
++m_progressStatus;
m_ui->m_progress->setValue((int)((float)m_progressStatus *(float)100 / (float)m_nbItem));
if (**m_listFile2Process_iterator)
{
startProcess();
return true;
}
else
{
endProcess();
return true;
}
}
else if (ValRet == KMessageBox::Cancel)
{
processAborted(false);
return false;
}
else
{
item->setDidOverWrite(true);
}
break;
}
case OVERWRITE_RENAME:
{
QFileInfo Target(targetAlbum + '/' + item->nameDest());
QString newFileName = RenameTargetImageFile(&Target);
if (newFileName.isNull())
{
item->changeResult(i18nc("batch process result", "Failed."));
item->changeError(i18n("destination image file already exists and cannot be renamed."));
++*m_listFile2Process_iterator;
++m_progressStatus;
m_ui->m_progress->setValue((int)((float)m_progressStatus *(float)100 / (float)m_nbItem));
if (**m_listFile2Process_iterator)
{
startProcess();
return true;
}
else
{
endProcess();
return true;
}
}
else
{
QFileInfo newTarget(newFileName);
item->changeNameDest(newTarget.fileName());
}
break;
}
case OVERWRITE_SKIP:
{
item->changeResult(i18n("Skipped."));
item->changeError(i18n("destination image file already exists (skipped automatically)."));
++*m_listFile2Process_iterator;
++m_progressStatus;
m_ui->m_progress->setValue((int)((float)m_progressStatus *(float)100 / (float)m_nbItem));
if (**m_listFile2Process_iterator)
{
startProcess();
return true;
}
else
{
endProcess();
return true;
}
break;
}
case OVERWRITE_OVER: // In this case do nothing : 'convert' default mode...
item->setDidOverWrite(true);
break;
default:
{
endProcess();
return true;
}
}
}
m_ProcessusProc = new KProcess(this);
m_ProcessusProc->setOutputChannelMode(KProcess::MergedChannels);
initProcess(m_ProcessusProc, item, targetAlbum);
m_commandLine = m_ProcessusProc->program().join(" ");
item->changeOutputMess(m_commandLine + "\n\n");
connect(m_ProcessusProc, SIGNAL(finished(int,QProcess::ExitStatus)),
this, SLOT(slotFinished()));
connect(m_ProcessusProc, SIGNAL(readyRead()),
this, SLOT(slotReadyRead()));
m_ProcessusProc->start();
if (!m_ProcessusProc->waitForStarted())
{
KMessageBox::error(this, i18n("Cannot start 'convert' program from 'ImageMagick' package;\n"
"please check your installation."));
delete m_ProcessusProc;
m_ProcessusProc = 0;
return false;
}
return true;
}
void BaseEditor::paintEvent(QPaintEvent *e)
{
//copy from QPlainTextEditor
QPainter painter(viewport());
Q_ASSERT(qobject_cast<QPlainTextDocumentLayout*>(document()->documentLayout()));
QPointF offset(contentOffset());
QRect er = e->rect();
QRect viewportRect = viewport()->rect();
bool editable = !isReadOnly();
QTextBlock block = firstVisibleBlock();
qreal maximumWidth = document()->documentLayout()->documentSize().width();
//margin
qreal lineX = 0;
if (conf->isDisplayRightColumnMargin()) {
// Don't use QFontMetricsF::averageCharWidth here, due to it returning
// a fractional size even when this is not supported by the platform.
lineX = QFontMetricsF(document()->defaultFont()).width(QLatin1Char('X')) * conf->getRightMarginColumn() + offset.x() + 4;
if (lineX < viewportRect.width()) {
const QBrush background = QBrush(QColor(239, 239, 239));
painter.fillRect(QRectF(lineX, er.top(), viewportRect.width() - lineX, er.height()),
background);
const QColor col = (palette().base().color().value() > 128) ? Qt::black : Qt::white;
const QPen pen = painter.pen();
painter.setPen(blendColors(background.isOpaque() ? background.color() : palette().base().color(),
col, 32));
painter.drawLine(QPointF(lineX, er.top()), QPointF(lineX, er.bottom()));
painter.setPen(pen);
}
}
// Set a brush origin so that the WaveUnderline knows where the wave started
painter.setBrushOrigin(offset);
// keep right margin clean from full-width selection
int maxX = offset.x() + qMax((qreal)viewportRect.width(), maximumWidth)
- document()->documentMargin();
er.setRight(qMin(er.right(), maxX));
painter.setClipRect(er);
QAbstractTextDocumentLayout::PaintContext context = getPaintContext();
while (block.isValid()) {
QRectF r = blockBoundingRect(block).translated(offset);
QTextLayout *layout = block.layout();
if (!block.isVisible()) {
offset.ry() += r.height();
block = block.next();
continue;
}
if (r.bottom() >= er.top() && r.top() <= er.bottom()) {
QTextBlockFormat blockFormat = block.blockFormat();
QBrush bg = blockFormat.background();
if (bg != Qt::NoBrush) {
QRectF contentsRect = r;
contentsRect.setWidth(qMax(r.width(), maximumWidth));
fillBackground(&painter, contentsRect, bg);
}
QVector<QTextLayout::FormatRange> selections;
int blpos = block.position();
int bllen = block.length();
for (int i = 0; i < context.selections.size(); ++i) {
const QAbstractTextDocumentLayout::Selection &range = context.selections.at(i);
const int selStart = range.cursor.selectionStart() - blpos;
const int selEnd = range.cursor.selectionEnd() - blpos;
if (selStart < bllen && selEnd > 0
&& selEnd > selStart) {
QTextLayout::FormatRange o;
o.start = selStart;
o.length = selEnd - selStart;
o.format = range.format;
selections.append(o);
} else if (!range.cursor.hasSelection() && range.format.hasProperty(QTextFormat::FullWidthSelection)
&& block.contains(range.cursor.position())) {
// for full width selections we don't require an actual selection, just
// a position to specify the line. that's more convenience in usage.
QTextLayout::FormatRange o;
QTextLine l = layout->lineForTextPosition(range.cursor.position() - blpos);
o.start = l.textStart();
o.length = l.textLength();
if (o.start + o.length == bllen - 1)
++o.length; // include newline
o.format = range.format;
selections.append(o);
}
}
bool drawCursor = ((editable || (textInteractionFlags() & Qt::TextSelectableByKeyboard))
&& context.cursorPosition >= blpos
&& context.cursorPosition < blpos + bllen);
bool drawCursorAsBlock = drawCursor && overwriteMode() ;
if (drawCursorAsBlock) {
if (context.cursorPosition == blpos + bllen - 1) {
drawCursorAsBlock = false;
} else {
QTextLayout::FormatRange o;
o.start = context.cursorPosition - blpos;
o.length = 1;
o.format.setForeground(palette().base());
o.format.setBackground(palette().text());
selections.append(o);
}
}
layout->draw(&painter, offset, selections, er);
if ((drawCursor && !drawCursorAsBlock)
|| (editable && context.cursorPosition < -1
&& !layout->preeditAreaText().isEmpty())) {
int cpos = context.cursorPosition;
if (cpos < -1)
cpos = layout->preeditAreaPosition() - (cpos + 2);
else
cpos -= blpos;
layout->drawCursor(&painter, offset, cpos, cursorWidth());
}
}
offset.ry() += r.height();
if (offset.y() > viewportRect.height())
break;
block = block.next();
}
if (backgroundVisible() && !block.isValid() && offset.y() <= er.bottom()
&& (centerOnScroll() || verticalScrollBar()->maximum() == verticalScrollBar()->minimum())) {
painter.fillRect(QRect(QPoint((int)er.left(), (int)offset.y()), er.bottomRight()), palette().background());
}
}
void HaiQTextEdit::process_key(QKeyEvent event) {
if ((event.text()!="")&&(textCursor().selectedText().count()<=1)) {
///this is to avoid spreading of marker highlighting
bool holdmodified=document()->isModified();
QTextCharFormat format=currentCharFormat();
format.clearBackground();
setCurrentCharFormat(format);
document()->setModified(holdmodified);
}
if ((event.key()==Qt::Key_Tab)||(event.key()==Qt::Key_Backtab)||(event.text()=="\t")) {
process_tab(event);
}
else if (event.key()==Qt::Key_Insert && QApplication::keyboardModifiers() == Qt::NoModifier) {
setOverwriteMode(!overwriteMode());
}
else if ((event.key()==Qt::Key_Home)&&((event.modifiers()==Qt::NoModifier)||(event.modifiers()==Qt::ShiftModifier))) {
bool shift_key=(event.modifiers()==Qt::ShiftModifier);
QTextCursor cursor=textCursor();
int col=cursor.columnNumber();
QString txt=cursor.block().text();
if (shift_key)
cursor.movePosition(QTextCursor::StartOfLine,QTextCursor::KeepAnchor);
else
cursor.movePosition(QTextCursor::StartOfLine);
int ct=0;
while ((ct<txt.count())&&((txt[ct]==' ')||(txt[ct]=='\t'))) {
if (shift_key)
cursor.movePosition(QTextCursor::Right,QTextCursor::KeepAnchor);
else
cursor.movePosition(QTextCursor::Right);
ct++;
}
int col2=cursor.columnNumber();
if (col2==col) { //moved nowhere
if (shift_key)
cursor.movePosition(QTextCursor::StartOfLine,QTextCursor::KeepAnchor);
else
cursor.movePosition(QTextCursor::StartOfLine);
}
setTextCursor(cursor);
}
else if (event.key()==Qt::Key_Backspace) {
process_backspace();
return;
}
else if ((event.key()==Qt::Key_Space)&&(event.modifiers()==Qt::ControlModifier)) {
return; // don't process a space, because Ctrl+Space is for completion
}
else {
QTextEdit::keyPressEvent(&event);
}
if ((event.key()==Qt::Key_Enter)||(event.key()==Qt::Key_Return)) {
indent_to_previous_line();
QTextCursor cursor=textCursor();
do_marker_highlighting(cursor);
QString line=cursor.block().previous().text();
QStringList symbols=split_into_symbols(line);
if ((symbols.count()>0)&&
( (symbols[symbols.count()-1]=="{") || (((symbols[symbols.count()-1]!=";"))&&((symbols[0]=="if") || (symbols[0]=="else") || (symbols[0]=="while") || (symbols[0]=="do") || (symbols[0]=="for"))) )
) {
QString line2=cursor.block().text();
QStringList symbols2=split_into_symbols(line2);
if ((symbols2.count()==0)||(symbols2[0]!="}")) //only indent if there is not a "{" starting the line
cursor.insertText(tab_text(cursor));
}
//kind of a hack
if (!blocks_highlighted_for_braces.isEmpty()) {
blocks_highlighted_for_braces << textCursor().block();
}
}
if (event.text()=="}") {
QTextCursor cursor=textCursor();
QString line=cursor.block().text();
QStringList symbols=split_into_symbols(line);
if (symbols.count()==1) {
//unindent to last brace
QTextBlock block=cursor.block();
bool found=false;
int braces_level=1;
while ((!found)&&(block.isValid())) {
block=block.previous();
QString line2=block.text();
QStringList symbols=split_into_symbols(line2);
for (int j=symbols.count()-1; j>=0; j--) {
if (symbols[j]=="{")
braces_level--;
if (symbols[j]=="}")
braces_level++;
if (braces_level==0)
found=true;
}
}
if (found) {
QString line2=block.text();
for (int j=0; j<line.count(); j++)
cursor.deletePreviousChar();
int j=0;
while ((j<line2.count())&&((line2[j]==' ')||(line2[j]=='\t'))) {
cursor.insertText(QString(line2[j]));
j++;
}
cursor.insertText("}");
}
}
}
if ((event.text()==")")||(event.text()=="}")/*||(event.text()==">")*/) {
highlight_braces(event.text(),true);
}
if ((event.text()=="(")||(event.text()=="{")/*||(event.text()=="<")*/) {
highlight_braces(event.text(),false);
}
}