bool RPCConsole::eventFilter(QObject* obj, QEvent *event)
{
if(event->type() == QEvent::KeyPress) // Special key handling
{
QKeyEvent *keyevt = static_cast<QKeyEvent*>(event);
int key = keyevt->key();
Qt::KeyboardModifiers mod = keyevt->modifiers();
switch(key)
{
case Qt::Key_Up: if(obj == ui->lineEdit) { browseHistory(-1); return true; } break;
case Qt::Key_Down: if(obj == ui->lineEdit) { browseHistory(1); return true; } break;
case Qt::Key_PageUp: /* pass paging keys to messages widget */
case Qt::Key_PageDown:
if(obj == ui->lineEdit)
{
QApplication::postEvent(ui->messagesWidget, new QKeyEvent(*keyevt));
return true;
}
break;
default:
// Typing in messages widget brings focus to line edit, and redirects key there
// Exclude most combinations and keys that emit no text, except paste shortcuts
if(obj == ui->messagesWidget && (
(!mod && !keyevt->text().isEmpty() && key != Qt::Key_Tab) ||
((mod & Qt::ControlModifier) && key == Qt::Key_V) ||
((mod & Qt::ShiftModifier) && key == Qt::Key_Insert)))
{
ui->lineEdit->setFocus();
QApplication::postEvent(ui->lineEdit, new QKeyEvent(*keyevt));
return true;
}
}
}
return QDialog::eventFilter(obj, event);
}
void QtEventConsumer::handleKeyPressEvent ( QObject *obj, QEvent *event )
{
// check the object
QWidget *widget = isValidWidget(obj);
if (!widget){
DEBUG(D_CONSUMER,"(QtEventConsumer::handleKeyPressEvent) No widget to handle");
return;
}
DEBUG(D_CONSUMER,"(QtEventConsumer::handleKeyPressEvent)");
QKeyEvent *keyEvent = dynamic_cast<QKeyEvent *> ( event );
//if it is a recognized key
if ( filterKeyEvent ( static_cast<Qt::Key> ( keyEvent->key() ) ) )
{
//create the event
QOE::QOE_KeyPress qoe;
qoe.timestamp(_timer.restart());
completeBasicData(qoe,widget);
qoe.key(keyEvent->key());
qoe.text(keyEvent->text());
qoe.modifiers(keyEvent->modifiers());
///sensitive value
completeSensitiveData(qoe, widget);
//send event if qoe is valid
if (isValidQOE(qoe) && isValidQOEKey(qoe))
sendNewTestItem(qoe);
}
}
bool ExpressionQueryWidget::eventFilter(QObject *obj, QEvent *event)
{
if (obj == m_textEdit) {
switch (event->type()) {
case QEvent::KeyPress:
{
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
int key = keyEvent->key();
if (key == Qt::Key_Return || key == Qt::Key_Enter) {
executeExpression();
return true;
} else if (key == Qt::Key_Backspace) {
// ensure m_expr doesn't contain backspace characters
QTextCursor cursor = m_textEdit->textCursor();
bool atLastLine = !(cursor.block().next().isValid());
if (!atLastLine)
return true;
if (cursor.columnNumber() <= m_prompt.count())
return true;
cursor.deletePreviousChar();
m_expr = cursor.block().text().mid(m_prompt.count());
return true;
} else {
m_textEdit->moveCursor(QTextCursor::End);
m_expr += keyEvent->text();
}
break;
}
case QEvent::FocusIn:
checkCurrentContext();
m_textEdit->moveCursor(QTextCursor::End);
break;
default:
break;
}
} else if (obj == m_lineEdit) {
switch (event->type()) {
case QEvent::KeyPress:
{
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
int key = keyEvent->key();
if (key == Qt::Key_Up && m_lineEdit->text() != m_lastExpr) {
m_expr = m_lineEdit->text();
if (!m_lastExpr.isEmpty())
m_lineEdit->setText(m_lastExpr);
} else if (key == Qt::Key_Down) {
m_lineEdit->setText(m_expr);
}
break;
}
case QEvent::FocusIn:
checkCurrentContext();
break;
default:
break;
}
}
return QWidget::eventFilter(obj, event);
}
/*!
\internal
*/
bool QCodeCompletionEngine::eventFilter(QObject *o, QEvent *e)
{
if ( !e || !o || (e->type() != QEvent::KeyPress) || (o != pEdit) )
return false;
//qDebug("should trigger completion?");
QDocumentCursor cur = editor()->cursor();
QKeyEvent *k = static_cast<QKeyEvent*>(e);
QString s, txt = s = k->text();
int count = txt.count();
if ( txt.isEmpty() || m_triggers.isEmpty() )
return false; // QThread::eventFilter(o, e);
//qDebug("should trigger completion? (bis)");
if ( count > m_max )
{
txt = txt.right(m_max);
} else if ( count < m_max ) {
QDocumentCursor c(cur);
c.movePosition(m_max - count, QDocumentCursor::Left, QDocumentCursor::KeepAnchor);
//qDebug("prev text : %s", qPrintable(c.selectedText()));
txt.prepend(c.selectedText());
}
//qDebug("text : %s", qPrintable(txt));
foreach ( QString trig, m_triggers )
{
if ( txt.endsWith(trig) )
{
editor()->write(s);
cur = editor()->cursor();
cur.movePosition(trig.count(), QDocumentCursor::PreviousCharacter);
// notify completion trigger
emit completionTriggered(trig);
//get rid of previous calltips/completions
editor()->setFocus();
// trigger completion
complete(cur, trig);
return true;
}
}
return false;
}
bool ShortcutGetter::event(QEvent *e)
{
if (!capture) return QDialog::event(e);
QString key;
QStringList mods;
QKeyEvent *k = static_cast<QKeyEvent*>(e);
switch ( e->type() )
{
case QEvent::KeyPress :
if ( bStop )
{
lKeys.clear();
bStop = false;
}
key = keyToString(k->key());
mods = modToString(k->modifiers());
//qDebug("event: key.count: %d, mods.count: %d", key.count(), mods.count());
if ( key.count() || mods.count() )
{
if ( key.count() && !lKeys.contains(key) )
lKeys << key;
foreach ( key, mods )
if ( !lKeys.contains(key) )
lKeys << key;
} else {
key = k->text();
if ( !lKeys.contains(key) )
lKeys << key;
}
setText();
break;
case QEvent::KeyRelease :
bStop = true;
break;
/*
case QEvent::ShortcutOverride :
leKey->setText("Shortcut override");
break;
*/
default:
return QDialog::event(e);
break;
}
bool SplashScreen::eventFilter(QObject * obj, QEvent * ev) {
if (ev->type() == QEvent::KeyPress) {
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
if(keyEvent->text()[0] == 'q') {
m_node.startShutdown();
}
}
return QObject::eventFilter(obj, ev);
}
bool SplashScreen::eventFilter(QObject * obj, QEvent * ev) {
if (ev->type() == QEvent::KeyPress) {
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(ev);
if(keyEvent->text()[0] == 'q' && breakAction != nullptr) {
breakAction();
}
}
return QObject::eventFilter(obj, ev);
}
bool KeyboardFilter::eventFilter( QObject *dist, QEvent *event )
{
if( event->type() == QEvent::KeyPress )
{
QKeyEvent *keyEvent = static_cast<QKeyEvent *>( event );
static QString digits = QString( "1234567890" );
if ( digits.indexOf( keyEvent->text() ) != -1 )
return true;
}
return QWidget::eventFilter( dist, event );
}
void QObjectProxy::interpretKeyEvent( QEvent *e, QList<QVariant> &args )
{
QKeyEvent *ke = static_cast<QKeyEvent*>( e );
QString text = ke->text();
int unicode = ( text.count() == 1 ? text[0].unicode() : 0 );
args << text;
args << (int) ke->modifiers();
args << unicode;
args << ke->key();
}
void EWAUserAction::execute( QWebView *webViewPtr ) const
{
if( !webViewPtr )
{
return;
}
//EWAWebView *pEwaWebView = qobject_cast<EWAWebView*>( webViewPtr );
//bool bNeedSetFocus = false;
QEvent *pEventCopy = 0;
if( isMouseEvent( m_pEvent->type() ) )
{
QMouseEvent *pSrcMouseEvent = static_cast<QMouseEvent *>( m_pEvent );
QPoint clickCoords = pSrcMouseEvent->pos();
pEventCopy = new QMouseEvent(
pSrcMouseEvent->type(),
clickCoords,
webViewPtr->mapToGlobal( clickCoords ),
pSrcMouseEvent->button(),
pSrcMouseEvent->buttons(),
pSrcMouseEvent->modifiers() );
}
else if( isKeyEvent( m_pEvent->type() ) )
{
QKeyEvent *pSrcKeyEvent = static_cast<QKeyEvent*>( m_pEvent );
pEventCopy = new QKeyEvent(
pSrcKeyEvent->type(),
pSrcKeyEvent->key(),
pSrcKeyEvent->modifiers(),
pSrcKeyEvent->text(),
pSrcKeyEvent->isAutoRepeat(),
pSrcKeyEvent->count() );
}
if( pEventCopy )
{
QSize dstSz = getWebViewSize();
if( webViewPtr->page()->preferredContentsSize() != dstSz )
{
webViewPtr->page()->setPreferredContentsSize( dstSz );
}
EWAApplication::postEvent( webViewPtr, pEventCopy );
}
}
bool WebPage::event(QEvent *ev)
{
QMouseEvent* mouseEvent = NULL;
QWheelEvent* wheelEvent = NULL;
QKeyEvent* keyEvent = NULL;
QByteArray byteArray;
QBuffer buffer(&byteArray);
buffer.open(QIODevice::ReadWrite);
QDataStream out(&buffer);
out << (int) ev->type();
switch (ev->type()) {
case QEvent::MouseMove:
case QEvent::MouseButtonPress:
case QEvent::MouseButtonDblClick:
case QEvent::MouseButtonRelease:
if (OPNET::OpNetwork::instance()->isReplay() || OPNET::OpNetwork::instance()->isReplica())
return false;
mouseEvent = (static_cast<QMouseEvent*>(ev));
out << mouseEvent->pos() << mouseEvent->globalPos()
<< (int) mouseEvent->button() << (int) mouseEvent->buttons()
<< (int) mouseEvent->modifiers();
OPNET::OpNetwork::instance()->sendSysCall(MSG_LOG_USER_INPUT, (int) ev->type(), byteArray);
break;
case QEvent::Wheel:
if (OPNET::OpNetwork::instance()->isReplay() || OPNET::OpNetwork::instance()->isReplica())
return false;;
wheelEvent = (static_cast<QWheelEvent*>(ev));
out << wheelEvent->pos() << wheelEvent->globalPos()
<< wheelEvent->delta() << (int) wheelEvent->buttons()
<< (int) wheelEvent->modifiers() << (int) wheelEvent->orientation();
OPNET::OpNetwork::instance()->sendSysCall(MSG_LOG_USER_INPUT, (int) ev->type(), byteArray);
break;
case QEvent::KeyPress:
case QEvent::KeyRelease:
if (OPNET::OpNetwork::instance()->isReplay() || OPNET::OpNetwork::instance()->isReplica())
return false;
keyEvent = (static_cast<QKeyEvent*>(ev));
out << keyEvent->key() << (int) keyEvent->modifiers()
<< keyEvent->text() << keyEvent->isAutoRepeat()
<< (int) keyEvent->count();
OPNET::OpNetwork::instance()->sendSysCall(MSG_LOG_USER_INPUT, (int) ev->type(), byteArray);
break;
default:
break;
}
return QWebPage::event(ev);
}
// protected virtual [base kpTool]
bool kpToolText::viewEvent (QEvent *e)
{
const bool isShortcutOverrideEvent =
(e->type () == QEvent::ShortcutOverride);
const bool haveTextSelection = document ()->textSelection ();
#if DEBUG_KP_TOOL_TEXT && 0
qCDebug(kpLogTools) << "kpToolText::viewEvent() type=" << e->type ()
<< " isShortcutOverrideEvent=" << isShortcutOverrideEvent
<< " haveTextSel=" << haveTextSelection
<< endl;
#endif
if (!isShortcutOverrideEvent || !haveTextSelection)
return kpAbstractSelectionTool::viewEvent (e);
QKeyEvent *ke = static_cast <QKeyEvent *> (e);
#if DEBUG_KP_TOOL_TEXT
qCDebug(kpLogTools) << "kpToolText::viewEvent() key=" << ke->key ()
<< " modifiers=" << ke->modifiers ()
<< " QChar.isPrint()=" << QChar (ke->key ()).isPrint ()
<< endl;
#endif
// Can't be shortcut?
if (ke->key () == 0 && ke->key () == Qt::Key_unknown)
{
#if DEBUG_KP_TOOL_TEXT
qCDebug(kpLogTools) << "\tcan't be shortcut - safe to not react";
#endif
}
// Normal letter (w/ or w/o shift, keypad button ok)?
// TODO: don't like this check
else if ((ke->modifiers () &
(Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier)) == 0 &&
!( ke->text ().isEmpty ()))
{
#if DEBUG_KP_TOOL_TEXT
qCDebug(kpLogTools) << "\tis text - grab";
#endif
e->accept ();
}
else
{
// Strickly speaking, we should grab stuff like the arrow keys
// and enter. In any case, should be done down in kpTool (as that
// uses arrow keys too).
}
return kpAbstractSelectionTool::event (e);
}
void
DBusInputContextConnection::sendKeyEvent(const QKeyEvent &keyEvent,
Maliit::EventRequestType requestType)
{
if (activeConnection) {
MInputContextConnection::sendKeyEvent(keyEvent, requestType);
ComMeegoInputmethodInputcontext1Interface *proxy = mProxys.value(activeConnection);
if (proxy) {
proxy->keyEvent(keyEvent.type(), keyEvent.key(), keyEvent.modifiers(),
keyEvent.text(), keyEvent.isAutoRepeat(), keyEvent.count(), requestType);
}
}
}
bool NamingDialog::eventFilter(QObject *object, QEvent *event)
{
if (event->type() == QEvent::KeyPress
&& object == ui.dateFormatComboBox)
{
QKeyEvent *keyEvent = (QKeyEvent*)(event);
if (QRegExp("[?:\\\\/*\"<>|]").exactMatch(keyEvent->text())) {
event->ignore();
return true;
}
}
return QDialog::eventFilter(object, event);
}
/*!
Se capturará un caso particular: El botón "." del teclado numérico, trasladando ese teclado,
si el sistema está asi configurado al separador de decimales por defecto del sistema
*/
bool DBNumberEditKeyPressEater::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() == QEvent::KeyPress) {
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
if ( ( keyEvent->modifiers() & Qt::KeypadModifier && keyEvent->text() == "." &&
configuracion.getLocale()->decimalPoint() != '.' ) ) {
QKeyEvent *ev = new QKeyEvent(QEvent::KeyPress, Qt::Key_Comma, 0, configuracion.getLocale()->decimalPoint());
QApplication::sendEvent(parent(), ev);
return true;
}
}
// standard event processing
return QObject::eventFilter(obj, event);
}
bool ScintillaEditor::eventFilter(QObject* obj, QEvent *e)
{
static bool wasChanged=false;
static bool previewAfterUndo=false;
if (obj != qsci) return EditorInterface::eventFilter(obj, e);
if ( e->type()==QEvent::KeyPress
|| e->type()==QEvent::KeyRelease
) {
QKeyEvent *ke = static_cast<QKeyEvent*>(e);
if ((ke->modifiers() & ~Qt::KeypadModifier) == Qt::AltModifier) {
switch (ke->key())
{
case Qt::Key_Left:
case Qt::Key_Right:
if (e->type()==QEvent::KeyPress) {
navigateOnNumber(ke->key());
}
return true;
case Qt::Key_Up:
case Qt::Key_Down:
if (e->type()==QEvent::KeyPress) {
if (!wasChanged) qsci->beginUndoAction();
if (modifyNumber(ke->key())) {
wasChanged=true;
previewAfterUndo=true;
}
if (!wasChanged) qsci->endUndoAction();
}
return true;
}
}
if (previewAfterUndo && e->type()==QEvent::KeyPress) {
int k=ke->key() | ke->modifiers();
if (wasChanged) qsci->endUndoAction();
wasChanged=false;
QsciCommand *cmd=qsci->standardCommands()->boundTo(k);
if ( cmd && ( cmd->command()==QsciCommand::Undo || cmd->command()==QsciCommand::Redo ) )
QTimer::singleShot(0,this,SIGNAL(previewRequest()));
else if ( cmd || !ke->text().isEmpty() ) {
// any insert or command (but not undo/redo) cancels the preview after undo
previewAfterUndo=false;
}
}
}
return false;
}
bool Window::eventFilter(QObject*, QEvent* event) {
if (event->type() != QEvent::KeyPress) {
return false;
}
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->key() == Qt::Key_Up || keyEvent->key() == Qt::Key_Down) {
QKeyEvent* newEvent = new QKeyEvent(
keyEvent->type(), keyEvent->key(), keyEvent->ascii(),
keyEvent->state(), keyEvent->text());
QApplication::postEvent(mView, newEvent);
return true;
}
return false;
}
bool SquareScene::event ( QEvent * e ) {
if(e->type() == QEvent::Enter)
emit enter(this->index);
else if(e->type() == QEvent::Leave)
emit exit(this->index);
else if(e->type() == QEvent::KeyPress) {
QKeyEvent* keyevent = dynamic_cast<QKeyEvent*>(e);
if(keyevent->key() >= Qt::Key_A && keyevent->key() <= Qt::Key_Z )
emit letterkeypress(this, keyevent->text());
else if(keyevent->key() == Qt::Key_Backspace)
emit delkeypress(this);
}
QGraphicsScene::event(e);
return true;
}
bool LuaConsole::eventFilter(QObject * watched, QEvent * event)
{
if (event->type() == QEvent::KeyPress)
{
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->modifiers() & Qt::AltModifier) {}
else if (keyEvent->modifiers() & Qt::MetaModifier) {}
else
{ // non-Ctrl keystrokes
switch(keyEvent->key())
{
// Use up and down arrows for history
case Qt::Key_Up:
showPreviousCommand();
return true;
case Qt::Key_Down:
showNextCommand();
return true;
// Prevent left arrow from leaving editing area
case Qt::Key_Left:
case Qt::Key_Backspace:
// Qt 4.6 lacks QTextCursor.positionInBlock
if((ui->plainTextEdit->textCursor().positionInBlock() == promptLength)
&& cursorIsInEditingRegion(ui->plainTextEdit->textCursor()) )
{
return true; // no moving left into prompt with arrow key
}
break;
// Trigger command execution with <Return>
case Qt::Key_Return:
case Qt::Key_Enter:
emit returnPressed();
return true; // Consume event. We will take care of inserting the newline.
}
// If this is a printing character, make sure the editing console is activated
if (keyEvent->text().length() > 0)
{
if ( ! cursorIsInEditingRegion(ui->plainTextEdit->textCursor()) )
ui->plainTextEdit->setTextCursor(latestGoodCursorPosition);
}
}
}
return QWidget::eventFilter(watched, event);
}
bool AvdDialog::eventFilter(QObject *obj, QEvent *event)
{
if (obj == m_avdDialog.nameLineEdit && event->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
const QString key = ke->text();
if (!key.isEmpty() && !m_allowedNameChars.exactMatch(key)) {
QPoint position = m_avdDialog.nameLineEdit->parentWidget()->mapToGlobal(m_avdDialog.nameLineEdit->geometry().bottomLeft());
position -= Utils::ToolTip::offsetFromPosition();
Utils::ToolTip::show(position, tr("Allowed characters are: a-z A-Z 0-9 and . _ -"), m_avdDialog.nameLineEdit);
m_hideTipTimer.start();
} else {
m_hideTipTimer.stop();
Utils::ToolTip::hide();
}
}
return QDialog::eventFilter(obj, event);
}
bool MainWindow::eventFilter(QObject* object, QEvent* event){
if (event->type() == QEvent::KeyPress){
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
int keyInt = keyEvent->key();
Qt::Key key = static_cast<Qt::Key>(keyInt);
// check for a combination of user clicks
Qt::KeyboardModifiers modifiers = keyEvent->modifiers();
QString keyText = keyEvent->text();
QList<Qt::Key> modifiersList;
if(modifiers & Qt::ShiftModifier)
keyInt += Qt::SHIFT;
if(modifiers & Qt::ControlModifier)
keyInt += Qt::CTRL;
if(modifiers & Qt::AltModifier)
keyInt += Qt::ALT;
if(modifiers & Qt::MetaModifier)
keyInt += Qt::META;
if (QKeySequence(keyInt).toString(QKeySequence::NativeText)=="Ctrl+C"){
keyCC = "Ctrl+C";
}
else{
if (QKeySequence(keyInt).toString(QKeySequence::NativeText)=="Ctrl+E" && keyCC == "Ctrl+C"){
keyCC = "";
beginEnd();
}
if (QKeySequence(keyInt).toString(QKeySequence::NativeText)=="Ctrl+J" && keyCC == "Ctrl+C"){
keyCC = "";
addItem();
}
else{
return QObject::eventFilter(object, event);
}
}
// qDebug() << "New KeySequence:" << QKeySequence(keyInt).toString(QKeySequence::NativeText);
}
else{
return QObject::eventFilter(object, event);
}
}
bool QAccel::eventFilter( QObject *o, QEvent *e )
{
if ( e->type() == QEvent::Reparent && d->watch == o ) {
repairEventFilter();
} else if ( d->enabled &&
( e->type() == QEvent::Accel ||
e->type() == QEvent::AccelAvailable) &&
d->watch && d->watch->isVisible() ) {
QKeyEvent *k = (QKeyEvent *)e;
int key = k->key();
if ( k->state() & ShiftButton )
key |= SHIFT;
if ( k->state() & ControlButton )
key |= CTRL;
if ( k->state() & AltButton )
key |= ALT;
QAccelItem *item = find_key( d->aitems, key, k->text()[0] );
if ( key == Key_unknown )
item = 0;
#ifndef QT_NO_WHATSTHIS
bool b = QWhatsThis::inWhatsThisMode();
#else
bool b = FALSE;
#endif
if ( item && ( item->enabled || b )) {
if (e->type() == QEvent::Accel) {
if ( b && !d->ignorewhatsthis ) {
#ifndef QT_NO_WHATSTHIS
QWhatsThis::leaveWhatsThisMode( item->whatsthis );
#endif
}
else if ( item->enabled ) {
if ( item->signal )
item->signal->activate();
else
emit activated( item->id );
}
}
k->accept();
return TRUE;
}
}
return QObject::eventFilter( o, e );
}
void qtnInitLineEdit(QLineEdit *lineEdit, QtnInplaceInfo *inplaceInfo)
{
if (!lineEdit || !inplaceInfo)
return;
if (!lineEdit->isReadOnly() && (inplaceInfo->activationEvent->type() == QEvent::KeyPress))
{
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(inplaceInfo->activationEvent);
if (qtnAcceptForLineEdit(keyEvent))
{
lineEdit->setText(keyEvent->text());
return;
}
}
else
{
lineEdit->selectAll();
}
}
bool TabManagerWidget::eventFilter(QObject* obj, QEvent* event)
{
if (event->type() == QEvent::KeyPress) {
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
const QString text = keyEvent->text().simplified();
if (obj == ui->treeWidget) {
// switch to tab/window on enter
if (keyEvent->key() == Qt::Key_Enter || keyEvent->key() == Qt::Key_Return) {
itemDoubleClick(ui->treeWidget->currentItem(), 0);
return QObject::eventFilter(obj, event);
}
if (!text.isEmpty() || ((keyEvent->modifiers() & Qt::ControlModifier) && keyEvent->key() == Qt::Key_F)) {
ui->filterBar->show();
ui->treeWidget->setFocusProxy(ui->filterBar);
ui->filterBar->setFocus();
if (!text.isEmpty() && text.at(0).isPrint()) {
ui->filterBar->setText(ui->filterBar->text() + text);
}
return true;
}
}
else if (obj == ui->filterBar) {
bool isNavigationOrActionKey = keyEvent->key() == Qt::Key_Up ||
keyEvent->key() == Qt::Key_Down ||
keyEvent->key() == Qt::Key_PageDown ||
keyEvent->key() == Qt::Key_PageUp ||
keyEvent->key() == Qt::Key_Enter ||
keyEvent->key() == Qt::Key_Return;
// send scroll or action press key to treeWidget
if (isNavigationOrActionKey) {
QKeyEvent ev(QKeyEvent::KeyPress, keyEvent->key(), keyEvent->modifiers());
QApplication::sendEvent(ui->treeWidget, &ev);
return false;
}
}
}
return QObject::eventFilter(obj, event);
}
// The following keyboard shortcuts should work (although
// they may not work consistently depending on focus):
// / (slash), Ctrl-F - Focus and highlight the search box
// Ctrl-G, Ctrl-N, F3 - Find next
// Should we make it so that typing any text starts searching?
bool FollowStreamDialog::eventFilter(QObject *, QEvent *event)
{
if (ui->teStreamContent->hasFocus() && event->type() == QEvent::KeyPress) {
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->matches(QKeySequence::SelectAll) || keyEvent->matches(QKeySequence::Copy)
|| keyEvent->text().isEmpty()) {
return false;
}
ui->leFind->setFocus();
if (keyEvent->matches(QKeySequence::Find)) {
return true;
} else if (keyEvent->matches(QKeySequence::FindNext)) {
findText();
return true;
}
}
return false;
}
bool QComposeInputContext::filterEvent(const QEvent *event)
{
// if there were errors when generating the compose table input
// context should not try to filter anything, simply return false
if ((m_tableState & TableGenerator::NoErrors) != TableGenerator::NoErrors)
return false;
QKeyEvent *keyEvent = (QKeyEvent *)event;
// should pass only the key presses
if (keyEvent->type() != QEvent::KeyPress) {
return false;
}
int keyval = keyEvent->key();
int keysym = 0;
if (ignoreKey(keyval))
return false;
QString text = keyEvent->text();
if (!composeKey(keyval) && text.isEmpty())
return false;
keysym = keyEvent->nativeVirtualKey();
int nCompose = 0;
while (m_composeBuffer[nCompose] != 0 && nCompose < QT_KEYSEQUENCE_MAX_LEN)
nCompose++;
if (nCompose == QT_KEYSEQUENCE_MAX_LEN) {
reset();
nCompose = 0;
}
m_composeBuffer[nCompose] = keysym;
// check sequence
if (checkComposeTable())
return true;
return false;
}
bool Recorder::eventFilter(QObject* /* o */, QEvent *e) {
if (e->type() == QEvent::KeyPress) {
QKeyEvent *keyEvent = (QKeyEvent*)(e);
uint curLine, curCol;
m_view->cursorPositionReal(&curLine, &curCol);
if(curLine != m_oldLine || m_oldCol+1 != curCol) {
m_typedSequence = QString();
m_oldLine = curLine;
m_oldCol = curCol;
}
else {
++m_oldCol;
}
m_typedSequence += keyEvent->text();
if(m_typedSequence.length() == m_maxSequenceLength+1) {
m_typedSequence = m_typedSequence.mid(1, m_typedSequence.length() - 1);
}
return seekForKeySequence(m_typedSequence);
}
return false;
}
bool interfacing::eventFilter(QObject *obj, QEvent *event){
if(event->type()== QEvent::KeyPress){
QKeyEvent* keyEvent = static_cast<QKeyEvent* >(event);
if(obj_port->isOpen()){
QString s = keyEvent->text();
if(s.length()){
char ch = s.at(0).toLatin1();
QByteArray chb= QByteArray::fromRawData(&ch,1);
obj_port->write(chb);
if(ui->chk_LocalEcho->isChecked()){
ui->txt_Terminal->insertPlainText(chb);
}
}
}
return true;
}
else{
return QObject::eventFilter(obj, event);
}
}
bool RKFunctionArgHinter::eventFilter (QObject *, QEvent *e) {
if (e->type () == QEvent::KeyPress || e->type () == QEvent::AccelOverride) {
RK_TRACE (COMMANDEDITOR); // avoid loads of empty traces, putting this here
QKeyEvent *k = static_cast<QKeyEvent *> (e);
if (k->key() == Qt::Key_Enter || k->key() == Qt::Key_Return || k->key () == Qt::Key_Up || k->key () == Qt::Key_Down || k->key () == Qt::Key_Left || k->key () == Qt::Key_Right || k->key () == Qt::Key_Home || k->key () == Qt::Key_Tab) {
hideArgHint ();
} else if (k->key () == Qt::Key_Backspace || k->key () == Qt::Key_Delete){
tryArgHint ();
} else {
QString text = k->text ();
if (text == "(") {
tryArgHint ();
} else if (text == ")") {
tryArgHint ();
}
}
}
return false;
}
bool AskPassphraseDialog::eventFilter(QObject *object, QEvent *event)
{
/* Detect Caps Lock.
* There is no good OS-independent way to check a key state in Qt, but we
* can detect Caps Lock by checking for the following condition:
* Shift key is down and the result is a lower case character, or
* Shift key is not down and the result is an upper case character.
*/
if (event->type() == QEvent::KeyPress) {
QKeyEvent *ke = static_cast<QKeyEvent *>(event);
QString str = ke->text();
if (str.length() != 0) {
const QChar *psz = str.unicode();
bool fShift = (ke->modifiers() & Qt::ShiftModifier) != 0;
if ((fShift && psz->isLower()) || (!fShift && psz->isUpper())) {
fCapsLock = true;
ui->capsLabel->setText(tr("Warning: The Caps Lock key is on!"));
} else if (psz->isLetter()) {
fCapsLock = false;
ui->capsLabel->clear();
}
}
}
return QDialog::eventFilter(object, event);
}
