Exemple #1
0
//*******************************************************
//* Override the event loop.  If the user presses "TAB"
//* and there is a valid tag entered, we signal the parent
//* that a new tag is needed.
//*******************************************************
bool  TagEditorNewTag::event(QEvent *event)
{
    QLOG_TRACE_IN() << typeid(*this).name();
    if (event->type() == QEvent::KeyPress) {
        QKeyEvent *ke = (QKeyEvent*)event;
        if (ke->key() == Qt::Key_Tab) {
            if (getText().trimmed() != "") {
                emit(tabPressed());
                QLOG_TRACE_OUT() << typeid(*this).name();
                return true;
            }
            QLOG_TRACE_OUT() << typeid(*this).name();
            return QLineEdit::event(event);
        }
    }
    QLOG_TRACE_OUT() << typeid(*this).name();
    return QLineEdit::event(event);
}
Exemple #2
0
void ChatTextEdit::keyPressEvent(QKeyEvent * event)
{    
    int key = event->key();
    if ((key == Qt::Key_Enter || key == Qt::Key_Return) && !(event->modifiers() & Qt::ShiftModifier))
        emit enterPressed();
    else if (key == Qt::Key_Tab)
        emit tabPressed();
    else if (key == Qt::Key_Up && this->toPlainText().isEmpty())
    {
        this->setText(lastMessage);
        this->setFocus();
        this->moveCursor(QTextCursor::MoveOperation::End,QTextCursor::MoveMode::MoveAnchor);
    }
    else
    {
        emit keyPressed();
        QTextEdit::keyPressEvent(event);
    }
}
Exemple #3
0
bool DatumTextItem::eventFilter(QObject* obj, QEvent* event)
{
    if (obj == this && event->type() == QEvent::KeyPress)
    {
        QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
        if (keyEvent->key() == Qt::Key_Tab)
            emit tabPressed(this);
        else if (keyEvent->key() == Qt::Key_Backtab)
            emit shiftTabPressed(this);
        else if (keyEvent->matches(QKeySequence::Undo))
            App::instance()->undo();
        else if (keyEvent->matches(QKeySequence::Redo))
            App::instance()->redo();
        else
            return false;
        return true;
    }
    return false;
}
bool KeyPressEater::eventFilter(QObject *obj, QEvent *event) {
	if (event->type() == QEvent::KeyPress) {
		QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
		if (keyEvent->key() == Qt::Key_Return) {
			emit enterPressed(obj);
			return true;
		}
		else if (keyEvent->key() == Qt::Key_Tab) {
			emit tabPressed();
			return true;
		}
		else {
			return QObject::eventFilter(obj, event);
		}
	}
	else {
		return QObject::eventFilter(obj, event);
	}
}
bool ChatbarTextEdit::event(QEvent *evt) {
	if (evt->type() == QEvent::ShortcutOverride) {
		return false;
	}

	if (evt->type() == QEvent::KeyPress) {
		QKeyEvent *kev = static_cast<QKeyEvent*>(evt);
		if ((kev->key() == Qt::Key_Enter || kev->key() == Qt::Key_Return) && !(kev->modifiers() & Qt::ShiftModifier)) {
			g.mw->sendChatbarMessage();
			return true;
		}
		if (kev->key() == Qt::Key_Tab) {
			emit tabPressed();
			return true;
		} else if (kev->key() == Qt::Key_Space && kev->modifiers() == Qt::ControlModifier) {
			emit ctrlSpacePressed();
			return true;
		}
	}
	return QTextEdit::event(evt);
}
Exemple #6
0
// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
// keyboard handling
// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- 
void FileListView::keyPressEvent( QKeyEvent* keyEvent )
{
    // implementing our needs
    Qt::KeyboardModifiers   keyboardModifier    = keyEvent->modifiers();
    Qt::Key                 pressedKey          = static_cast<Qt::Key>( keyEvent->key() );

    if( Qt::NoModifier == keyboardModifier )
    {
        switch( pressedKey )
        {
            case Qt::Key_Escape:    emit escPressed();      break;

            case Qt::Key_Period:    emit consolePressed();  break;

            case Qt::Key_F1 :       emit f01keyPressed();   break;
            case Qt::Key_F2 :       emit f02keyPressed();   break;
            case Qt::Key_F3 :       emit f03keyPressed();   break;
            case Qt::Key_F4 :       emit f04keyPressed();   break;
            case Qt::Key_F5 :       emit f05keyPressed();   break;
            case Qt::Key_F6 :       emit f06keyPressed();   break;
            case Qt::Key_F7 :       emit f07keyPressed();   break;
            case Qt::Key_F8 :       emit f08keyPressed();   break;
            case Qt::Key_F9 :       emit f09keyPressed();   break;
            case Qt::Key_F10:       emit f10keyPressed();   break;
            case Qt::Key_F11:       emit f11keyPressed();   break;
            case Qt::Key_F12:       emit f12keyPressed();   break;

            case Qt::Key_Print:     emit printPressed();    break;
            case Qt::Key_Pause:     emit pausePressed();    break;

            case Qt::Key_Tab:       emit tabPressed();      break;
            case Qt::Key_CapsLock:  emit capsLockPressed(); break;
            case Qt::Key_Shift:     emit leftShiftPressed();break;
            case Qt::Key_Control:   emit leftCtrlPressed(); break;

            case Qt::Key_Insert:    emit insertPressed();   break;
            case Qt::Key_Delete:    emit deletePressed();   break;
            case Qt::Key_Home:      emit homePressed();     break;
            case Qt::Key_End:       emit endPressed();      break;
            case Qt::Key_PageUp:    emit pageUpPressed();   break;
            case Qt::Key_PageDown:  emit pageDownPressed(); break;

            case Qt::Key_Backspace: emit backspacePressed();break;
            case Qt::Key_Return:    emit enterPressed();    break;
            case Qt::Key_Space:     emit spacePressed();    break;

            default:                keyEvent->ignore();     break;
        }
    }

    else if( Qt::AltModifier == keyboardModifier )
    {
        switch( pressedKey )
        {
            case Qt::Key_0: emit alt0Pressed(); break;
            case Qt::Key_1: emit alt1Pressed(); break;
            case Qt::Key_2: emit alt2Pressed(); break;
            case Qt::Key_3: emit alt3Pressed(); break;
            case Qt::Key_4: emit alt4Pressed(); break;
            case Qt::Key_5: emit alt5Pressed(); break;
            case Qt::Key_6: emit alt6Pressed(); break;
            case Qt::Key_7: emit alt7Pressed(); break;
            case Qt::Key_8: emit alt8Pressed(); break;
            case Qt::Key_9: emit alt9Pressed(); break;
            default:        keyEvent->ignore(); break;
        }
    }

    else if( Qt::ControlModifier == keyboardModifier )
    {
        switch( pressedKey )
        {
            case Qt::Key_0: emit ctrl0Pressed(); break;
            case Qt::Key_1: emit ctrl1Pressed(); break;
            case Qt::Key_2: emit ctrl2Pressed(); break;
            case Qt::Key_3: emit ctrl3Pressed(); break;
            case Qt::Key_4: emit ctrl4Pressed(); break;
            case Qt::Key_5: emit ctrl5Pressed(); break;
            case Qt::Key_6: emit ctrl6Pressed(); break;
            case Qt::Key_7: emit ctrl7Pressed(); break;
            case Qt::Key_8: emit ctrl8Pressed(); break;
            case Qt::Key_9: emit ctrl9Pressed(); break;
            default:        keyEvent->ignore();  break;
        }
    }

    else if( Qt::ShiftModifier == keyboardModifier )
    {
        switch( pressedKey )
        {
            case Qt::Key_0: emit shift0Pressed(); break;
            case Qt::Key_1: emit shift1Pressed(); break;
            case Qt::Key_2: emit shift2Pressed(); break;
            case Qt::Key_3: emit shift3Pressed(); break;
            case Qt::Key_4: emit shift4Pressed(); break;
            case Qt::Key_5: emit shift5Pressed(); break;
            case Qt::Key_6: emit shift6Pressed(); break;
            case Qt::Key_7: emit shift7Pressed(); break;
            case Qt::Key_8: emit shift8Pressed(); break;
            case Qt::Key_9: emit shift9Pressed(); break;
            default:        keyEvent->ignore();   break;
        }
    }

    else if( Qt::KeypadModifier == keyboardModifier )
    {
        switch( pressedKey )
        {
            case Qt::Key_Minus:     emit numpadMinusPressed();      break;
            case Qt::Key_Plus:      emit numpadPlusPressed();       break;
            case Qt::Key_Slash:     emit numpadSlashPressed();      break;
            case Qt::Key_Asterisk:  emit numpadAsteriskPressed();   break;
            default:                keyEvent->ignore();             break;
        }
    }

    // allowing the default behaviour
    QListView::keyPressEvent( keyEvent );
}
bool CmdPromptInput::eventFilter(QObject* obj, QEvent* event)
{
    if(event->type() == QEvent::KeyPress)
    {
        QKeyEvent* pressedKey = (QKeyEvent*)event;

        //NOTE: These shortcuts need to be caught since QLineEdit uses them
        if(pressedKey->matches(QKeySequence::Cut))
        {
            pressedKey->accept();
            emit cutPressed();
            return true;
        }
        else if(pressedKey->matches(QKeySequence::Copy))
        {
            pressedKey->accept();
            emit copyPressed();
            return true;
        }
        else if(pressedKey->matches(QKeySequence::Paste))
        {
            pressedKey->accept();
            emit pastePressed();
            return true;
        }
        else if(pressedKey->matches(QKeySequence::SelectAll))
        {
            pressedKey->accept();
            emit selectAllPressed();
            return true;
        }
        else if(pressedKey->matches(QKeySequence::Undo))
        {
            pressedKey->accept();
            emit undoPressed();
            return true;
        }
        else if(pressedKey->matches(QKeySequence::Redo))
        {
            pressedKey->accept();
            emit redoPressed();
            return true;
        }

        int key = pressedKey->key();
        switch(key)
        {
            case Qt::Key_Enter:
            case Qt::Key_Return:
            case Qt::Key_Space:
                pressedKey->accept();
                processInput(QChar(key));
                return true;
                break;
            case Qt::Key_Delete:
                pressedKey->accept();
                emit deletePressed();
                return true;
                break;
            case Qt::Key_Tab:
                pressedKey->accept();
                emit tabPressed();
                return true;
                break;
            case Qt::Key_Escape:
                pressedKey->accept();
                prefix = "Command: ";
                clear();
                emit appendHistory(curText + tr("*Cancel*"));
                emit escapePressed();
                return true;
                break;
            case Qt::Key_F1:
                pressedKey->accept();
                emit F1Pressed();
                return true;
                break;
            case Qt::Key_F2:
                pressedKey->accept();
                emit F2Pressed();
                return true;
                break;
            case Qt::Key_F3:
                pressedKey->accept();
                emit F3Pressed();
                return true;
                break;
            case Qt::Key_F4:
                pressedKey->accept();
                emit F4Pressed();
                return true;
                break;
            case Qt::Key_F5:
                emit F5Pressed();
                pressedKey->accept();
                return true;
                break;
            case Qt::Key_F6:
                pressedKey->accept();
                emit F6Pressed();
                return true;
                break;
            case Qt::Key_F7:
                pressedKey->accept();
                emit F7Pressed();
                return true;
                break;
            case Qt::Key_F8:
                pressedKey->accept();
                emit F8Pressed();
                return true;
                break;
            case Qt::Key_F9:
                pressedKey->accept();
                emit F9Pressed();
                return true;
                break;
            case Qt::Key_F10:
                pressedKey->accept();
                emit F10Pressed();
                return true;
                break;
            case Qt::Key_F11:
                pressedKey->accept();
                emit F11Pressed();
                return true;
                break;
            case Qt::Key_F12:
                pressedKey->accept();
                emit F12Pressed();
                return true;
                break;
            default:
                pressedKey->ignore();
        }
    }
    return QObject::eventFilter(obj, event);
}
CmdPrompt::CmdPrompt(QWidget* parent) : QWidget(parent)
{
    qDebug("CmdPrompt Constructor");
    setObjectName("Command Prompt");

    promptInput = new CmdPromptInput(this);
    promptHistory = new CmdPromptHistory();
    promptDivider = new QFrame(this);
    promptVBoxLayout = new QVBoxLayout(this);

    promptSplitter = new CmdPromptSplitter(this);

    this->setFocusProxy(promptInput);
    promptHistory->setFocusProxy(promptInput);

    promptDivider->setLineWidth(1);
    promptDivider->setFrameStyle(QFrame::HLine);
    promptDivider->setMaximumSize(QWIDGETSIZE_MAX, 1);

    promptVBoxLayout->addWidget(promptSplitter);
    promptVBoxLayout->addWidget(promptHistory);
    promptVBoxLayout->addWidget(promptDivider);
    promptVBoxLayout->addWidget(promptInput);

    promptVBoxLayout->setSpacing(0);
    promptVBoxLayout->setContentsMargins(0,0,0,0);

    this->setLayout(promptVBoxLayout);

    styleHash = new QHash<QString, QString>();
    styleHash->insert("color",                      "#000000"); // Match -------|
    styleHash->insert("background-color",           "#FFFFFF"); //              |
    styleHash->insert("selection-color",            "#FFFFFF"); //              |
    styleHash->insert("selection-background-color", "#000000"); // Match -------|
    styleHash->insert("font-family",              "Monospace");
    styleHash->insert("font-style",                  "normal");
    styleHash->insert("font-size",                     "12px");

    updateStyle();

    this->show();

    connect(promptInput, SIGNAL(appendHistory(const QString&)), promptHistory, SLOT(appendHistory(const QString&)));
    connect(this, SIGNAL(appendTheHistory(const QString&)), promptHistory, SLOT(appendHistory(const QString&)));

    //For use outside of command prompt
    connect(promptInput, SIGNAL(startCommand(const QString&)), this, SIGNAL(startCommand(const QString&)));
    connect(promptInput, SIGNAL(runCommand(const QString&, const QString&)), this, SIGNAL(runCommand(const QString&, const QString&)));
    connect(promptInput, SIGNAL(deletePressed()),    this, SIGNAL(deletePressed()));
    connect(promptInput, SIGNAL(tabPressed()),       this, SIGNAL(tabPressed()));
    connect(promptInput, SIGNAL(escapePressed()),    this, SIGNAL(escapePressed()));
    connect(promptInput, SIGNAL(F1Pressed()),        this, SIGNAL(F1Pressed()));
    connect(promptInput, SIGNAL(F2Pressed()),        this, SIGNAL(F2Pressed()));
    connect(promptInput, SIGNAL(F3Pressed()),        this, SIGNAL(F3Pressed()));
    connect(promptInput, SIGNAL(F4Pressed()),        this, SIGNAL(F4Pressed()));
    connect(promptInput, SIGNAL(F5Pressed()),        this, SIGNAL(F5Pressed()));
    connect(promptInput, SIGNAL(F6Pressed()),        this, SIGNAL(F6Pressed()));
    connect(promptInput, SIGNAL(F7Pressed()),        this, SIGNAL(F7Pressed()));
    connect(promptInput, SIGNAL(F8Pressed()),        this, SIGNAL(F8Pressed()));
    connect(promptInput, SIGNAL(F9Pressed()),        this, SIGNAL(F9Pressed()));
    connect(promptInput, SIGNAL(F10Pressed()),       this, SIGNAL(F10Pressed()));
    connect(promptInput, SIGNAL(F11Pressed()),       this, SIGNAL(F11Pressed()));
    connect(promptInput, SIGNAL(F12Pressed()),       this, SIGNAL(F12Pressed()));
    connect(promptInput, SIGNAL(cutPressed()),       this, SIGNAL(cutPressed()));
    connect(promptInput, SIGNAL(copyPressed()),      this, SIGNAL(copyPressed()));
    connect(promptInput, SIGNAL(pastePressed()),     this, SIGNAL(pastePressed()));
    connect(promptInput, SIGNAL(selectAllPressed()), this, SIGNAL(selectAllPressed()));
    connect(promptInput, SIGNAL(undoPressed()),      this, SIGNAL(undoPressed()));
    connect(promptInput, SIGNAL(redoPressed()),      this, SIGNAL(redoPressed()));
}