AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move shortcut handling back into QPA and simplify delivery

Browse Source 
Commit 7f5b94b47 moved shortcut handling into QGuiApplication (for all
platforms except OS X), due to crashes on Android where the events are
delivered from another thread.

Now that we have synchronous event delivery (also across threads) from
QPA, this is no longer needed, and we can move the code back to QPA,
where the platform has more control over when and how shortcut events
are delivered in relation to normal key events.

Handling shortcuts is as before a two step process. We first send a
QKeyEvent::ShortcutOverride event to the active window, which allows
clients (widgets e.g.) to signal that they want to handle the shortcut
themselves. If the override event is accepted, we treat it as the
shortcut not being handled as a regular shortcut, and send the event
as a key press instead, allowing the widget to handle the shortcut.

If nothing accepted the shortcut override event we pass it along to
the global shortcut map, which will treat the event as handled if
an exact or partial match is found.

The QShortcutMap::tryShortcutEvent() and nextState() implementation
has been simplified to not use the events accepted state for its
internal operation, which removes the need for saving the state
of the incoming event.

The QKeyEvent::ShortcutOverride event was also always sent with
the accepted state set to false, by calling ignore() on it before
sending it. This is now explicit by having shortcut override
events being ignored by default in their constructor, and the
documentation has been updated accordingly.

Change-Id: I9afa29dbc00bef09fd22ee6bf09661b06340d715
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@theqtcompany.com>
Reviewed-by: Christian Stromme <christian.stromme@theqtcompany.com>
This commit is contained in:
Tor Arne Vestbø 2015-09-04 17:56:20 +02:00
parent 590c73bee2
commit c7e5e1d9e0
8 changed files with 109 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/gui/kernel/qevent.cpp
View File

@ -1029,8 +1029,10 @@ QWheelEvent::QWheelEvent(const QPointF &pos, const QPointF& globalPos,
when keys are pressed or released.
A key event contains a special accept flag that indicates whether
the receiver will handle the key event. This flag is set by default,
so there is no need to call accept() when acting on a key event.
the receiver will handle the key event. This flag is set by default
for QEvent::KeyPress and QEvent::KeyRelease, so there is no need to
call accept() when acting on a key event. For QEvent::ShortcutOverride
the receiver needs to explicitly accept the event to trigger the override.
Calling ignore() on a key event will propagate it to the parent widget.
The event is propagated up the parent widget chain until a widget
accepts it or an event filter consumes it.
@ -1065,6 +1067,8 @@ QKeyEvent::QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const
nScanCode(0), nVirtualKey(0), nModifiers(0),
c(count), autor(autorep)
{
if (type == QEvent::ShortcutOverride)
ignore();
}
/*!
@ -1092,6 +1096,8 @@ QKeyEvent::QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers,
nScanCode(nativeScanCode), nVirtualKey(nativeVirtualKey), nModifiers(nativeModifiers),
c(count), autor(autorep)
{
if (type == QEvent::ShortcutOverride)
ignore();
}

13
src/gui/kernel/qguiapplication.cpp
View File

@ -1915,19 +1915,6 @@ void QGuiApplicationPrivate::processKeyEvent(QWindowSystemInterfacePrivate::KeyE
window = QGuiApplication::focusWindow();
}
#if !defined(Q_OS_OSX)
// On OS X the shortcut override is checked earlier, see: QWindowSystemInterface::handleKeyEvent()
const bool checkShortcut = e->keyType == QEvent::KeyPress && window != 0;
if (checkShortcut) {
QKeyEvent override(QEvent::ShortcutOverride, e->key, e->modifiers,
e->nativeScanCode, e->nativeVirtualKey, e->nativeModifiers,
e->unicode, e->repeat, e->repeatCount);
override.setTimestamp(e->timestamp);
if (QWindowSystemInterface::tryHandleShortcutOverrideEvent(window, &override))
return;
}
#endif // Q_OS_OSX
QKeyEvent ev(e->keyType, e->key, e->modifiers,
e->nativeScanCode, e->nativeVirtualKey, e->nativeModifiers,
e->unicode, e->repeat, e->repeatCount);

59
src/gui/kernel/qshortcutmap.cpp
View File

@ -309,59 +309,42 @@ QKeySequence::SequenceMatch QShortcutMap::state()
}
/*! \internal
Uses ShortcutOverride event to see if any widgets want to override
the event. If not, uses nextState(QKeyEvent) to check for a grabbed
Shortcut, and dispatchEvent() is found and identical.
Uses nextState(QKeyEvent) to check for a grabbed shortcut.
\note that this function should only be called from QWindowSystemInterface,
otherwise it will result in duplicate events.
If so, it is dispatched using dispatchEvent().
Returns true if a shortcut handled the event.
\sa nextState, dispatchEvent
*/
bool QShortcutMap::tryShortcutEvent(QObject *o, QKeyEvent *e)
bool QShortcutMap::tryShortcut(QKeyEvent *e)
{
Q_D(QShortcutMap);
if (e->key() == Qt::Key_unknown)
return false;
bool wasAccepted = e->isAccepted();
bool wasSpontaneous = e->spont;
if (d->currentState == QKeySequence::NoMatch) {
ushort orgType = e->t;
e->t = QEvent::ShortcutOverride;
e->ignore();
QCoreApplication::sendEvent(o, e);
e->t = orgType;
e->spont = wasSpontaneous;
if (e->isAccepted()) {
if (!wasAccepted)
e->ignore();
return false;
}
}
QKeySequence::SequenceMatch previousState = state();
QKeySequence::SequenceMatch result = nextState(e);
bool stateWasAccepted = e->isAccepted();
if (wasAccepted)
e->accept();
else
e->ignore();
int identicalMatches = d->identicals.count();
switch(result) {
switch (nextState(e)) {
case QKeySequence::NoMatch:
return stateWasAccepted;
// In the case of going from a partial match to no match we handled the
// event, since we already stated that we did for the partial match. But
// in the normal case of directly going to no match we say we didn't.
return previousState == QKeySequence::PartialMatch;
case QKeySequence::PartialMatch:
// For a partial match we don't know yet if we will handle the shortcut
// but we need to say we did, so that we get the follow-up key-presses.
return true;
case QKeySequence::ExactMatch:
resetState();
dispatchEvent(e);
// If there are no identicals we've only found disabled shortcuts, and
// shouldn't say that we handled the event.
return d->identicals.count() > 0;
default:
break;
Q_UNREACHABLE();
}
// If nextState is QKeySequence::ExactMatch && identicals.count == 0
// we've only found disabled shortcuts
return identicalMatches > 0 || result == QKeySequence::PartialMatch;
}
/*! \internal
@ -396,10 +379,6 @@ QKeySequence::SequenceMatch QShortcutMap::nextState(QKeyEvent *e)
}
}
// Should we eat this key press?
if (d->currentState == QKeySequence::PartialMatch
|| (d->currentState == QKeySequence::ExactMatch && d->identicals.count()))
e->accept();
// Does the new state require us to clean up?
if (result == QKeySequence::NoMatch)
clearSequence(d->currentSequences);

5
src/gui/kernel/qshortcutmap_p.h
View File

@ -75,7 +75,9 @@ public:
int setShortcutEnabled(bool enable, int id, QObject *owner, const QKeySequence &key = QKeySequence());
int setShortcutAutoRepeat(bool on, int id, QObject *owner, const QKeySequence &key = QKeySequence());
bool tryShortcutEvent(QObject *o, QKeyEvent *e);
QKeySequence::SequenceMatch state();
bool tryShortcut(QKeyEvent *e);
bool hasShortcutForKeySequence(const QKeySequence &seq) const;
#ifdef Dump_QShortcutMap
@ -85,7 +87,6 @@ public:
private:
void resetState();
QKeySequence::SequenceMatch nextState(QKeyEvent *e);
QKeySequence::SequenceMatch state();
void dispatchEvent(QKeyEvent *e);
QKeySequence::SequenceMatch find(QKeyEvent *e, int ignoredModifiers = 0);

178
src/gui/kernel/qwindowsysteminterface.cpp
View File

@ -41,6 +41,7 @@
#include <qpa/qplatformintegration.h>
#include <qdebug.h>
#include "qhighdpiscaling_p.h"
#include <QtCore/qscopedvaluerollback.h>
QT_BEGIN_NAMESPACE
@ -191,114 +192,50 @@ void QWindowSystemInterface::handleFrameStrutMouseEvent(QWindow *w, ulong timest
QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
}
bool QWindowSystemInterface::tryHandleShortcutEvent(QWindow *w, int k, Qt::KeyboardModifiers mods,
const QString & text, bool autorep, ushort count)
{
unsigned long timestamp = QWindowSystemInterfacePrivate::eventTime.elapsed();
return tryHandleShortcutEvent(w, timestamp, k, mods, text, autorep, count);
}
bool QWindowSystemInterface::tryHandleShortcutEvent(QWindow *w, ulong timestamp, int k, Qt::KeyboardModifiers mods,
const QString & text, bool autorep, ushort count)
bool QWindowSystemInterface::handleShortcutEvent(QWindow *window, ulong timestamp, int keyCode, Qt::KeyboardModifiers modifiers, quint32 nativeScanCode,
quint32 nativeVirtualKey, quint32 nativeModifiers, const QString &text, bool autorepeat, ushort count)
{
#ifndef QT_NO_SHORTCUT
QGuiApplicationPrivate::modifier_buttons = mods;
if (!window)
window = QGuiApplication::focusWindow();
if (!w)
w = QGuiApplication::focusWindow();
if (!w)
return false;
QShortcutMap &shortcutMap = QGuiApplicationPrivate::instance()->shortcutMap;
if (shortcutMap.state() == QKeySequence::NoMatch) {
// Check if the shortcut is overridden by some object in the event delivery path (typically the focus object).
// If so, we should not look up the shortcut in the shortcut map, but instead deliver the event as a regular
// key event, so that the target that accepted the shortcut override event can handle it. Note that we only
// do this if the shortcut map hasn't found a partial shortcut match yet. If it has, the shortcut can not be
// overridden.
QWindowSystemInterfacePrivate::KeyEvent *shortcutOverrideEvent = new QWindowSystemInterfacePrivate::KeyEvent(window, timestamp,
QEvent::ShortcutOverride, keyCode, modifiers, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorepeat, count);
QObject *focus = w->focusObject();
if (!focus)
focus = w;
{
// FIXME: Template handleWindowSystemEvent to support both sync and async delivery
QScopedValueRollback<bool> syncRollback(QWindowSystemInterfacePrivate::synchronousWindowSystemEvents);
QWindowSystemInterfacePrivate::synchronousWindowSystemEvents = true;
QKeyEvent qevent(QEvent::ShortcutOverride, k, mods, text, autorep, count);
qevent.setTimestamp(timestamp);
return QGuiApplicationPrivate::instance()->shortcutMap.tryShortcutEvent(focus, &qevent);
if (QWindowSystemInterfacePrivate::handleWindowSystemEvent(shortcutOverrideEvent))
return false;
}
}
// The shortcut event is dispatched as a QShortcutEvent, not a QKeyEvent, but we use
// the QKeyEvent as a container for the various properties that the shortcut map needs
// to inspect to determine if a shortcut matched the keys that were pressed.
QKeyEvent keyEvent(QEvent::ShortcutOverride, keyCode, modifiers, nativeScanCode,
nativeVirtualKey, nativeModifiers, text, autorepeat, count);
return shortcutMap.tryShortcut(&keyEvent);
#else
Q_UNUSED(w)
Q_UNUSED(window)
Q_UNUSED(timestamp)
Q_UNUSED(k)
Q_UNUSED(mods)
Q_UNUSED(text)
Q_UNUSED(autorep)
Q_UNUSED(count)
return false;
#endif
}
bool QWindowSystemInterface::tryHandleShortcutOverrideEvent(QWindow *w, QKeyEvent *ev)
{
#ifndef QT_NO_SHORTCUT
Q_ASSERT(ev->type() == QKeyEvent::ShortcutOverride);
QGuiApplicationPrivate::modifier_buttons = ev->modifiers();
QObject *focus = w->focusObject();
if (!focus)
focus = w;
return QGuiApplicationPrivate::instance()->shortcutMap.tryShortcutEvent(focus, ev);
#else
Q_UNUSED(w)
Q_UNUSED(ev)
return false;
#endif
}
// used by QTestLib to directly send shortcuts to objects
bool QWindowSystemInterface::tryHandleShortcutEventToObject(QObject *o, ulong timestamp, int k, Qt::KeyboardModifiers mods,
const QString &text, bool autorep, ushort count)
{
#ifndef QT_NO_SHORTCUT
QGuiApplicationPrivate::modifier_buttons = mods;
QKeyEvent qevent(QEvent::ShortcutOverride, k, mods, text, autorep, count);
qevent.setTimestamp(timestamp);
return QGuiApplicationPrivate::instance()->shortcutMap.tryShortcutEvent(o, &qevent);
#else
Q_UNUSED(w)
Q_UNUSED(timestamp)
Q_UNUSED(k)
Q_UNUSED(mods)
Q_UNUSED(text)
Q_UNUSED(autorep)
Q_UNUSED(count)
return false;
#endif
}
bool QWindowSystemInterface::tryHandleExtendedShortcutEvent(QWindow *w, int k, Qt::KeyboardModifiers mods,
quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers,
const QString &text, bool autorep, ushort count)
{
unsigned long timestamp = QWindowSystemInterfacePrivate::eventTime.elapsed();
return tryHandleExtendedShortcutEvent(w, timestamp, k, mods, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count);
}
bool QWindowSystemInterface::tryHandleExtendedShortcutEvent(QWindow *w, ulong timestamp, int k, Qt::KeyboardModifiers mods,
quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers,
const QString &text, bool autorep, ushort count)
{
#ifndef QT_NO_SHORTCUT
QGuiApplicationPrivate::modifier_buttons = mods;
QObject *focus = w->focusObject();
if (!focus)
focus = w;
QKeyEvent qevent(QEvent::ShortcutOverride, k, mods, nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count);
qevent.setTimestamp(timestamp);
return QGuiApplicationPrivate::instance()->shortcutMap.tryShortcutEvent(focus, &qevent);
#else
Q_UNUSED(w)
Q_UNUSED(timestamp)
Q_UNUSED(k)
Q_UNUSED(mods)
Q_UNUSED(key)
Q_UNUSED(modifiers)
Q_UNUSED(nativeScanCode)
Q_UNUSED(nativeVirtualKey)
Q_UNUSED(nativeModifiers)
Q_UNUSED(text)
Q_UNUSED(autorep)
Q_UNUSED(autorepeat)
Q_UNUSED(count)
return false;
#endif
@ -312,13 +249,8 @@ bool QWindowSystemInterface::handleKeyEvent(QWindow *w, QEvent::Type t, int k, Q
bool QWindowSystemInterface::handleKeyEvent(QWindow *tlw, ulong timestamp, QEvent::Type t, int k, Qt::KeyboardModifiers mods, const QString & text, bool autorep, ushort count)
{
// This is special handling needed for OS X which eventually will call sendEvent(), on other platforms
// this might not be safe, e.g., on Android. See: QGuiApplicationPrivate::processKeyEvent() for
// shortcut overriding on other platforms.
#if defined(Q_OS_OSX)
if (t == QEvent::KeyPress && QWindowSystemInterface::tryHandleShortcutEvent(tlw, timestamp, k, mods, text))
if (t == QEvent::KeyPress && QWindowSystemInterface::handleShortcutEvent(tlw, timestamp, k, mods, 0, 0, 0, text, autorep, count))
return true;
#endif // Q_OS_OSX
QWindowSystemInterfacePrivate::KeyEvent * e =
new QWindowSystemInterfacePrivate::KeyEvent(tlw, timestamp, t, k, mods, text, autorep, count);
@ -343,7 +275,9 @@ bool QWindowSystemInterface::handleExtendedKeyEvent(QWindow *tlw, ulong timestam
const QString& text, bool autorep,
ushort count, bool tryShortcutOverride)
{
Q_UNUSED(tryShortcutOverride)
if (tryShortcutOverride && type == QEvent::KeyPress && QWindowSystemInterface::handleShortcutEvent(tlw, timestamp, key, modifiers, 0, 0, 0, text, autorep, count))
return true;
QWindowSystemInterfacePrivate::KeyEvent * e =
new QWindowSystemInterfacePrivate::KeyEvent(tlw, timestamp, type, key, modifiers,
nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count);
@ -926,9 +860,41 @@ Q_GUI_EXPORT void qt_handleKeyEvent(QWindow *w, QEvent::Type t, int k, Qt::Keybo
QWindowSystemInterface::setSynchronousWindowSystemEvents(wasSynchronous);
}
Q_GUI_EXPORT bool qt_sendShortcutOverrideEvent(QObject *o, ulong timestamp, int k, Qt::KeyboardModifiers mods, const QString &text = QString(), bool autorep = false, ushort count = 1)
Q_GUI_EXPORT bool qt_handleShortcutEvent(QObject *o, ulong timestamp, int k, Qt::KeyboardModifiers mods, const QString &text = QString(), bool autorep = false, ushort count = 1)
{
return QWindowSystemInterface::tryHandleShortcutEventToObject(o, timestamp, k, mods, text, autorep, count);
#ifndef QT_NO_SHORTCUT
// FIXME: This method should not allow targeting a specific object, but should
// instead forward the event to a window, which then takes care of normal event
// propagation. We need to fix a lot of tests before we can refactor this (the
// window needs to be exposed and active and have a focus object), so we leave
// it as is for now. See QTBUG-48577.
QGuiApplicationPrivate::modifier_buttons = mods;
QKeyEvent qevent(QEvent::ShortcutOverride, k, mods, text, autorep, count);
qevent.setTimestamp(timestamp);
QShortcutMap &shortcutMap = QGuiApplicationPrivate::instance()->shortcutMap;
if (shortcutMap.state() == QKeySequence::NoMatch) {
// Try sending as QKeyEvent::ShortcutOverride first
QCoreApplication::sendEvent(o, &qevent);
if (qevent.isAccepted())
return false;
}
// Then as QShortcutEvent
return shortcutMap.tryShortcut(&qevent);
#else
Q_UNUSED(o)
Q_UNUSED(timestamp)
Q_UNUSED(k)
Q_UNUSED(mods)
Q_UNUSED(text)
Q_UNUSED(autorep)
Q_UNUSED(count)
return false;
#endif
}
static QWindowSystemInterface::TouchPoint touchPoint(const QTouchEvent::TouchPoint& pt)

18
src/gui/kernel/qwindowsysteminterface.h
View File

@ -78,22 +78,8 @@ public:
Qt::KeyboardModifiers mods = Qt::NoModifier,
Qt::MouseEventSource source = Qt::MouseEventNotSynthesized);
static bool tryHandleShortcutOverrideEvent(QWindow *w, QKeyEvent *ev);
static bool tryHandleShortcutEvent(QWindow *w, int k, Qt::KeyboardModifiers mods,
const QString & text = QString(), bool autorep = false, ushort count = 1);
static bool tryHandleShortcutEvent(QWindow *w, ulong timestamp, int k, Qt::KeyboardModifiers mods,
const QString & text = QString(), bool autorep = false, ushort count = 1);
static bool tryHandleShortcutEventToObject(QObject *o, ulong timestamp, int k, Qt::KeyboardModifiers mods,
const QString & text = QString(), bool autorep = false, ushort count = 1);
static bool tryHandleExtendedShortcutEvent(QWindow *w, int k, Qt::KeyboardModifiers mods,
quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers,
const QString & text = QString(), bool autorep = false, ushort count = 1);
static bool tryHandleExtendedShortcutEvent(QWindow *w, ulong timestamp, int k, Qt::KeyboardModifiers mods,
quint32 nativeScanCode, quint32 nativeVirtualKey, quint32 nativeModifiers,
const QString & text = QString(), bool autorep = false, ushort count = 1);
static bool handleShortcutEvent(QWindow *w, ulong timestamp, int k, Qt::KeyboardModifiers mods, quint32 nativeScanCode,
quint32 nativeVirtualKey, quint32 nativeModifiers, const QString & text = QString(), bool autorep = false, ushort count = 1);
static bool handleKeyEvent(QWindow *w, QEvent::Type t, int k, Qt::KeyboardModifiers mods, const QString & text = QString(), bool autorep = false, ushort count = 1);
static bool handleKeyEvent(QWindow *w, ulong timestamp, QEvent::Type t, int k, Qt::KeyboardModifiers mods, const QString & text = QString(), bool autorep = false, ushort count = 1);

6
src/plugins/platforms/cocoa/qnsview.mm
View File

@ -1446,10 +1446,8 @@ static QTabletEvent::TabletDevice wacomTabletDevice(NSEvent *theEvent)
if (eventType == QEvent::KeyPress) {
if (m_composingText.isEmpty()) {
QKeyEvent override(QEvent::ShortcutOverride, keyCode, modifiers,
nativeScanCode, nativeVirtualKey, nativeModifiers, text, [nsevent isARepeat], 1);
override.setTimestamp(timestamp);
m_sendKeyEvent = !QWindowSystemInterface::tryHandleShortcutOverrideEvent(focusWindow, &override);
m_sendKeyEvent = !QWindowSystemInterface::handleShortcutEvent(focusWindow, timestamp, keyCode,
modifiers, nativeScanCode, nativeVirtualKey, nativeModifiers, text, [nsevent isARepeat], 1);
}
QObject *fo = QGuiApplication::focusObject();

6
src/testlib/qtestkeyboard.h
View File

@ -57,7 +57,7 @@
QT_BEGIN_NAMESPACE
Q_GUI_EXPORT void qt_handleKeyEvent(QWindow *w, QEvent::Type t, int k, Qt::KeyboardModifiers mods, const QString & text = QString(), bool autorep = false, ushort count = 1);
Q_GUI_EXPORT bool qt_sendShortcutOverrideEvent(QObject *o, ulong timestamp, int k, Qt::KeyboardModifiers mods, const QString &text = QString(), bool autorep = false, ushort count = 1);
Q_GUI_EXPORT bool qt_handleShortcutEvent(QObject *o, ulong timestamp, int k, Qt::KeyboardModifiers mods, const QString &text = QString(), bool autorep = false, ushort count = 1);
namespace QTest
{
@ -97,7 +97,7 @@ namespace QTest
if (action == Shortcut) {
int timestamp = 0;
qt_sendShortcutOverrideEvent(window, timestamp, code, modifier, text, repeat);
qt_handleShortcutEvent(window, timestamp, code, modifier, text, repeat);
return;
}
@ -178,7 +178,7 @@ namespace QTest
QKeyEvent a(press ? QEvent::KeyPress : QEvent::KeyRelease, code, modifier, text, repeat);
QSpontaneKeyEvent::setSpontaneous(&a);
if (press && qt_sendShortcutOverrideEvent(widget, a.timestamp(), code, modifier, text, repeat))
if (press && qt_handleShortcutEvent(widget, a.timestamp(), code, modifier, text, repeat))
return;
if (!qApp->notify(widget, &a))
QTest::qWarn("Keyboard event not accepted by receiving widget");