KKeySequenceButton Class Reference

#include <kkeysequencewidget_p.h>

Inheritance diagram for KKeySequenceButton:

Public Member Functions
	KKeySequenceButton (KisKKeySequenceWidgetPrivate *d, QWidget *parent)
	~KKeySequenceButton () override

Protected Member Functions
bool	event (QEvent *event) override
void	keyPressEvent (QKeyEvent *event) override
void	keyReleaseEvent (QKeyEvent *event) override

Private Attributes
KisKKeySequenceWidgetPrivate *const	d

Detailed Description

Definition at line 12 of file kkeysequencewidget_p.h.

Constructor & Destructor Documentation

KKeySequenceButton()

KKeySequenceButton::KKeySequenceButton ( KisKKeySequenceWidgetPrivate * d, QWidget * parent )

inlineexplicit

Definition at line 17 of file kkeysequencewidget_p.h.

        : QPushButton(parent),
          d(d) {}

~KKeySequenceButton()

KKeySequenceButton::~KKeySequenceButton ( )

override

Definition at line 602 of file kkeysequencewidget.cpp.

{
}

Member Function Documentation

event()

bool KKeySequenceButton::event ( QEvent * event )

overrideprotected

Reimplemented for internal reasons.

Definition at line 607 of file kkeysequencewidget.cpp.

{
    if (d->isRecording && e->type() == QEvent::KeyPress) {
        keyPressEvent(static_cast<QKeyEvent *>(e));
        return true;
    }
 
    // The shortcut 'alt+c' ( or any other dialog local action shortcut )
    // ended the recording and triggered the action associated with the
    // action. In case of 'alt+c' ending the dialog.  It seems that those
    // ShortcutOverride events get sent even if grabKeyboard() is active.
    if (d->isRecording && e->type() == QEvent::ShortcutOverride) {
        e->accept();
        return true;
    }
 
    if (d->isRecording && e->type() == QEvent::ContextMenu) {
        // is caused by Qt::Key_Menu
        e->accept();
        return true;
    }
 
    return QPushButton::event(e);
}

References d, KisKKeySequenceWidgetPrivate::isRecording, and keyPressEvent().

keyPressEvent()

void KKeySequenceButton::keyPressEvent ( QKeyEvent * event )

overrideprotected

Here is the trap, which is different on every OS. On Windows, Qt has incomprehensible rules on translating AltGr-related key sequences into shortcuts. On macOS symbols may confuse Qt when using Cmd+Shift-based shortcuts. * So we should just ask Qt itself what it expects to receive as a shortcut :)

That is exactly what Qt's QKeySequenceEdit does internally.

TODO: in the future replace the whole widget with QKeySequenceEdit, it uses QKeyMapper directly.

Take the first element, which is usually the shortcut form the latin layout of the keyboard

Definition at line 829 of file kkeysequencewidget.cpp.

{
    int keyQt = e->key();
    if (keyQt == -1) {
        // Qt sometimes returns garbage keycodes, I observed -1, if it doesn't know a key.
        // We cannot do anything useful with those (several keys have -1, indistinguishable)
        // and QKeySequence.toString() will also yield a garbage string.
        KMessageBox::error(this,
                           i18n("The key you just pressed is not supported by Qt."),
                           i18n("Unsupported Key"));
        return d->cancelRecording();
    }
 
    uint newModifiers = e->modifiers() & (Qt::SHIFT | Qt::CTRL | Qt::ALT | Qt::META);
 
    //don't have the return or space key appear as first key of the sequence when they
    //were pressed to start editing - catch and them and imitate their effect
    if (!d->isRecording && ((keyQt == Qt::Key_Return || keyQt == Qt::Key_Space))) {
        d->startRecording();
        d->modifierKeys = newModifiers;
        d->updateShortcutDisplay();
        return;
    }
 
    // We get events even if recording isn't active.
    if (!d->isRecording) {
        return QPushButton::keyPressEvent(e);
    }
 
    e->accept();
    d->modifierKeys = newModifiers;
 
    switch (keyQt) {
    case Qt::Key_AltGr: //or else we get unicode salad
        return;
    case Qt::Key_Shift:
    case Qt::Key_Control:
    case Qt::Key_Alt:
    case Qt::Key_Meta:
    case Qt::Key_Super_L:
    case Qt::Key_Super_R:
        d->controlModifierlessTimeout();
        d->updateShortcutDisplay();
        break;
    default:
 
        if (d->nKey == 0 && !(d->modifierKeys & ~Qt::SHIFT)) {
            // It's the first key and no modifier pressed. Check if this is
            // allowed
            if (!(KisKKeySequenceWidgetPrivate::isOkWhenModifierless(keyQt)
                    || d->allowModifierless)) {
                // No it's not
                return;
            }
        }
 
        // We now have a valid key press.
        if (keyQt) {
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
            const QList<int> vec = QKeyMapper::possibleKeys(e);
#else
            const QList<QKeyCombination> vec = QKeyMapper::possibleKeys(e);
#endif
 
            if (!vec.isEmpty() && e->modifiers() != Qt::NoModifier) {
                keyQt = vec.first();
            } else if ((keyQt == Qt::Key_Backtab) && (d->modifierKeys & Qt::SHIFT)) {
                keyQt = Qt::Key_Tab | d->modifierKeys;
            } else if (isShiftAsModifierAllowed(keyQt)) {
                keyQt |= d->modifierKeys;
            } else {
                keyQt |= (d->modifierKeys & ~Qt::SHIFT);
            }
 
            if (d->nKey == 0) {
                d->keySequence = QKeySequence(keyQt);
            } else {
                d->keySequence =
                    KisKKeySequenceWidgetPrivate::appendToSequence(d->keySequence, keyQt);
            }
 
            d->nKey++;
            if ((!d->multiKeyShortcutsAllowed) || (d->nKey >= 4)) {
                d->doneRecording();
                return;
            }
            d->controlModifierlessTimeout();
            d->updateShortcutDisplay();
        }
    }
}

References KisKKeySequenceWidgetPrivate::allowModifierless, KisKKeySequenceWidgetPrivate::appendToSequence(), KisKKeySequenceWidgetPrivate::cancelRecording(), KisKKeySequenceWidgetPrivate::controlModifierlessTimeout(), d, KisKKeySequenceWidgetPrivate::doneRecording(), KisKKeySequenceWidgetPrivate::isOkWhenModifierless(), KisKKeySequenceWidgetPrivate::isRecording, KisKKeySequenceWidgetPrivate::keySequence, KisKKeySequenceWidgetPrivate::modifierKeys, KisKKeySequenceWidgetPrivate::multiKeyShortcutsAllowed, KisKKeySequenceWidgetPrivate::nKey, KisKKeySequenceWidgetPrivate::startRecording(), and KisKKeySequenceWidgetPrivate::updateShortcutDisplay().

keyReleaseEvent()

void KKeySequenceButton::keyReleaseEvent ( QKeyEvent * event )

overrideprotected

Definition at line 937 of file kkeysequencewidget.cpp.

{
    if (e->key() == -1) {
        // ignore garbage, see keyPressEvent()
        return;
    }
 
    if (!d->isRecording) {
        return QPushButton::keyReleaseEvent(e);
    }
 
    e->accept();
 
    uint newModifiers = e->modifiers() & (Qt::SHIFT | Qt::CTRL | Qt::ALT | Qt::META);
 
    //if a modifier that belongs to the shortcut was released...
    if ((newModifiers & d->modifierKeys) < d->modifierKeys) {
        d->modifierKeys = newModifiers;
        d->controlModifierlessTimeout();
        d->updateShortcutDisplay();
    }
}

References KisKKeySequenceWidgetPrivate::controlModifierlessTimeout(), d, KisKKeySequenceWidgetPrivate::isRecording, KisKKeySequenceWidgetPrivate::modifierKeys, and KisKKeySequenceWidgetPrivate::updateShortcutDisplay().

Member Data Documentation

d

KisKKeySequenceWidgetPrivate* const KKeySequenceButton::d

private

Definition at line 32 of file kkeysequencewidget_p.h.

---

The documentation for this class was generated from the following files:

• libs/widgetutils/xmlgui/kkeysequencewidget_p.h
• libs/widgetutils/xmlgui/kkeysequencewidget.cpp