Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package plasma6-keyboard for
openSUSE:Factory checked in at 2026-07-02 20:09:14
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/plasma6-keyboard (Old)
and /work/SRC/openSUSE:Factory/.plasma6-keyboard.new.1982 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "plasma6-keyboard"
Thu Jul 2 20:09:14 2026 rev:9 rq:1362841 version:6.7.2
Changes:
--------
--- /work/SRC/openSUSE:Factory/plasma6-keyboard/plasma6-keyboard.changes
2026-06-25 10:55:12.793247520 +0200
+++
/work/SRC/openSUSE:Factory/.plasma6-keyboard.new.1982/plasma6-keyboard.changes
2026-07-02 20:12:13.323142845 +0200
@@ -1,0 +2,11 @@
+Tue Jun 30 20:14:04 UTC 2026 - Fabian Vogt <[email protected]>
+
+- Update to 6.7.2:
+ * New bugfix release
+ * For more details see https://kde.org/announcements/plasma/6/6.7.2
+- Changes since 6.7.1:
+ * Update version for new release 6.7.2
+ * fix(overlay): allow clients to receive actual key events
(kde#519339,kde#521128,kde#521718,kde#521772,kde#521789,kde#521872,kde#522024,kde#522152,kde#522167)
+ * Update version for new release 6.7.2
+
+-------------------------------------------------------------------
Old:
----
plasma-keyboard-6.7.1.tar.xz
plasma-keyboard-6.7.1.tar.xz.sig
New:
----
plasma-keyboard-6.7.2.tar.xz
plasma-keyboard-6.7.2.tar.xz.sig
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ plasma6-keyboard.spec ++++++
--- /var/tmp/diff_new_pack.llRurP/_old 2026-07-02 20:12:14.019166929 +0200
+++ /var/tmp/diff_new_pack.llRurP/_new 2026-07-02 20:12:14.027167206 +0200
@@ -30,7 +30,7 @@
%{!?_plasma6_version: %define _plasma6_version %(echo %{_plasma6_bugfix} | awk
-F. '{print $1"."$2}')}
%bcond_without released
Name: plasma6-keyboard
-Version: 6.7.1
+Version: 6.7.2
Release: 0
Summary: Virtual Keyboard for Qt based desktops
License: GPL-2.0-or-later AND GPL-3.0-only
++++++ plasma-keyboard-6.7.1.tar.xz -> plasma-keyboard-6.7.2.tar.xz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/plasma-keyboard-6.7.1/CMakeLists.txt
new/plasma-keyboard-6.7.2/CMakeLists.txt
--- old/plasma-keyboard-6.7.1/CMakeLists.txt 2026-06-23 10:15:21.000000000
+0200
+++ new/plasma-keyboard-6.7.2/CMakeLists.txt 2026-06-30 14:34:00.000000000
+0200
@@ -3,7 +3,7 @@
cmake_minimum_required(VERSION 3.16)
-set(PROJECT_VERSION "6.7.1")
+set(PROJECT_VERSION "6.7.2")
project(plasma-keyboard VERSION ${PROJECT_VERSION})
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/plasma-keyboard-6.7.1/src/inputmethod.cpp
new/plasma-keyboard-6.7.2/src/inputmethod.cpp
--- old/plasma-keyboard-6.7.1/src/inputmethod.cpp 2026-06-23
10:15:21.000000000 +0200
+++ new/plasma-keyboard-6.7.2/src/inputmethod.cpp 2026-06-30
14:34:00.000000000 +0200
@@ -143,6 +143,11 @@
void Keyboard::keyboard_key(uint32_t serial, uint32_t time, uint32_t key,
uint32_t state)
{
+ // Store the serial and time from the compositor so they can be used later
+ // by InputPlugin::key() for synthetic key event forwarding.
+ m_parent->m_lastKeyboardSerial = serial;
+ m_parent->m_lastKeyboardTime = time;
+
auto code = key + 8; // map to
wl_keyboard::keymap_format::keymap_format_xkb_v1
xkb_keysym_t sym = xkb_state_key_get_one_sym(mXkbState.get(), code);
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/plasma-keyboard-6.7.1/src/inputmethod_p.h
new/plasma-keyboard-6.7.2/src/inputmethod_p.h
--- old/plasma-keyboard-6.7.1/src/inputmethod_p.h 2026-06-23
10:15:21.000000000 +0200
+++ new/plasma-keyboard-6.7.2/src/inputmethod_p.h 2026-06-30
14:34:00.000000000 +0200
@@ -64,6 +64,8 @@
uint32_t m_cursor = 0;
uint32_t m_anchor = 0;
uint32_t m_latestSerial = 0;
+ uint32_t m_lastKeyboardSerial = 0;
+ uint32_t m_lastKeyboardTime = 0;
InputPlugin::ContentHint m_contentHint = InputPlugin::content_hint_none;
InputPlugin::ContentPurpose m_contentPurpose =
InputPlugin::content_purpose_normal;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/plasma-keyboard-6.7.1/src/inputplugin.cpp
new/plasma-keyboard-6.7.2/src/inputplugin.cpp
--- old/plasma-keyboard-6.7.1/src/inputplugin.cpp 2026-06-23
10:15:21.000000000 +0200
+++ new/plasma-keyboard-6.7.2/src/inputplugin.cpp 2026-06-30
14:34:00.000000000 +0200
@@ -106,6 +106,14 @@
m_context->keysym(m_context->m_latestSerial, timestamp, sym, state,
modifiers);
}
+void InputPlugin::key(KeyState state, quint32 scancode)
+{
+ if (!m_context) {
+ return;
+ }
+ m_context->key(m_context->m_lastKeyboardSerial,
m_context->m_lastKeyboardTime, scancode, static_cast<uint32_t>(state));
+}
+
InputPlugin::ContentHint InputPlugin::contentHint() const
{
if (!m_context) {
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/plasma-keyboard-6.7.1/src/inputplugin.h
new/plasma-keyboard-6.7.2/src/inputplugin.h
--- old/plasma-keyboard-6.7.1/src/inputplugin.h 2026-06-23 10:15:21.000000000
+0200
+++ new/plasma-keyboard-6.7.2/src/inputplugin.h 2026-06-30 14:34:00.000000000
+0200
@@ -73,9 +73,11 @@
enum KeyState {
Released = 0,
- Pressed = 1
+ Pressed = 1,
+ Repeated = 2
};
void keysym(uint timestamp, uint sym, KeyState state, uint modifiers);
+ void key(KeyState state, quint32 scancode);
ContentHint contentHint() const;
ContentPurpose contentPurpose() const;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/plasma-keyboard-6.7.1/src/org.kde.plasma.keyboard.metainfo.xml
new/plasma-keyboard-6.7.2/src/org.kde.plasma.keyboard.metainfo.xml
--- old/plasma-keyboard-6.7.1/src/org.kde.plasma.keyboard.metainfo.xml
2026-06-23 10:15:21.000000000 +0200
+++ new/plasma-keyboard-6.7.2/src/org.kde.plasma.keyboard.metainfo.xml
2026-06-30 14:34:00.000000000 +0200
@@ -268,6 +268,7 @@
<binary>plasma-keyboard</binary>
</provides>
<releases>
+ <release version="6.7.2" date="2026-06-30"/>
<release version="6.7.1" date="2026-06-23"/>
<release version="6.7.0" date="2026-06-16"/>
</releases>
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/plasma-keyboard-6.7.1/src/overlay/longpresstrigger.cpp
new/plasma-keyboard-6.7.2/src/overlay/longpresstrigger.cpp
--- old/plasma-keyboard-6.7.1/src/overlay/longpresstrigger.cpp 2026-06-23
10:15:21.000000000 +0200
+++ new/plasma-keyboard-6.7.2/src/overlay/longpresstrigger.cpp 2026-06-30
14:34:00.000000000 +0200
@@ -60,36 +60,17 @@
return result;
}
- // Characters with diacritic candidates enter the long-press hold timer
- // (consumed, blocking native auto-repeat). Printable characters
without
- // diacritics are consumed and committed via commit_string too, but
skip
- // the pending state so the controller's repeat-suppression check does
- // not catch them.
- const QChar baseChar = keyEvent->text().at(0).toLower();
- if (m_diacriticsMap.contains(baseChar)) {
- if (keyEvent->isAutoRepeat()) {
- // Diacritic auto-repeat: let the controller's pending-key
check
- // suppress it; don't consume here, so the event falls through.
- return result;
- }
- m_timerStarted = true;
- result.action = OverlayAction::StartTimer;
- result.consumeEvent = true;
- result.pendingText = keyEvent->text();
- result.pendingNativeScanCode = keyEvent->nativeScanCode();
- result.timerDurationMs = m_holdThresholdMs;
- } else {
- // Printable character without diacritics: consume and commit via
- // commit_string for ordering consistency. Since we are accepting
the key
- // event, ask the controller to synthesise repeats with its own
internal
- // timer to retain native key repeat behavior.
- result.action = OverlayAction::ConsumeEvent;
- result.consumeEvent = true;
- result.commitText = keyEvent->text();
- result.enableRepeat = true;
- result.repeatScanCode = keyEvent->nativeScanCode();
- result.pendingNativeScanCode = keyEvent->nativeScanCode();
- }
+ // Request timer start for long-press detection.
+ // Consume the raw key event to prevent it from being forwarded via
+ // wl_keyboard, which would trigger client-side auto-repeat. Instead,
+ // the controller commits the base character immediately via
+ // commit_string (no repeat) and retracts it if the overlay opens.
+ m_timerStarted = true;
+ result.action = OverlayAction::StartTimer;
+ result.consumeEvent = true;
+ result.pendingText = keyEvent->text();
+ result.pendingNativeScanCode = keyEvent->nativeScanCode();
+ result.timerDurationMs = m_holdThresholdMs;
// qCDebug(PlasmaKeyboard) << "LongPressTrigger: Requesting timer for"
<< text << "duration" << m_holdThresholdMs << "ms";
break;
@@ -179,6 +160,10 @@
return false;
}
+ if (event->isAutoRepeat()) {
+ return false;
+ }
+
// Only handle simple textual keys without control/meta modifiers
const Qt::KeyboardModifiers mods = event->modifiers();
const bool modifierAllowed = mods == Qt::NoModifier || mods ==
Qt::ShiftModifier;
@@ -186,13 +171,9 @@
return false;
}
- // Intercept all printable characters so they are consistently committed
via
- // commit_string, avoiding ordering issues between commit and key event
paths
- // (e.g. when a password manager injects key events, if they arrive via
multiple
- // pathways the ordering could be inconsistent). See:
- // https://invent.kde.org/plasma/plasma-keyboard/-/merge_requests/131
+ // Check if we have diacritics for this character
const QChar baseChar = event->text().at(0).toLower();
- return baseChar.isPrint();
+ return m_diacriticsMap.contains(baseChar);
}
#include "moc_longpresstrigger.cpp"
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/plasma-keyboard-6.7.1/src/overlay/overlaycontroller.cpp
new/plasma-keyboard-6.7.2/src/overlay/overlaycontroller.cpp
--- old/plasma-keyboard-6.7.1/src/overlay/overlaycontroller.cpp 2026-06-23
10:15:21.000000000 +0200
+++ new/plasma-keyboard-6.7.2/src/overlay/overlaycontroller.cpp 2026-06-30
14:34:00.000000000 +0200
@@ -18,9 +18,6 @@
m_holdTimer.setSingleShot(true);
connect(&m_holdTimer, &QTimer::timeout, this,
&OverlayController::handleTimerExpired);
- m_repeatTimer.setSingleShot(true);
- connect(&m_repeatTimer, &QTimer::timeout, this,
&OverlayController::handleRepeatTimer);
-
m_overlayGraceTimer.setSingleShot(true);
connect(&m_overlayGraceTimer, &QTimer::timeout, this,
&OverlayController::handleOverlayGraceTimer);
@@ -87,9 +84,6 @@
// Compare by native scan code (physical key) rather than Qt key code,
because
// the Qt key code can change if the modifier is released before the
repeat fires
// (e.g. Shift+/ produces Key_Question on press but Key_Slash on repeat).
- //
- // Suppress auto-repeat key events for the pending key (diacritic
long-press)
- // or for a key being repeated by our internal timer (non-diacritic
ConsumeEvent).
if (event->isAutoRepeat() && (event->nativeScanCode() ==
m_pendingNativeScanCode || event->nativeScanCode() == m_repeatNativeScanCode)) {
// qCDebug(PlasmaKeyboard) << "Suppressing repeat press of pending
overlay key" << m_pendingText;
return true;
@@ -196,25 +190,31 @@
return false;
}
+ // Compare by native scan code (physical key) so that modifier changes
+ // between press and release don't prevent the match.
+ bool keyMatchesPending = (event->nativeScanCode() ==
m_pendingNativeScanCode);
+
// If the overlay grace timer is running and the held key is released,
// stop the grace timer — the overlay stays visible waiting for selection
// or cancellation via the normal pathways.
- if (m_overlayGraceTimer.isActive() && event->nativeScanCode() ==
m_pendingNativeScanCode) {
+ if (m_overlayGraceTimer.isActive() && keyMatchesPending) {
+ // qCDebug(PlasmaKeyboard) << "Overlay grace timer stopped due to
release of held key" << m_pendingNativeScanCode;
m_overlayGraceTimer.stop();
}
- // Check for key release that should stop the internal repeat timer.
- // This must run before the swallow-release and pending-key checks since
- // it may share the same scan code.
- if (m_repeatNativeScanCode != 0 && event->nativeScanCode() ==
m_repeatNativeScanCode) {
- m_repeatTimer.stop();
- m_repeatText.clear();
+ bool keyRepeatActive = (m_repeatNativeScanCode != 0 &&
event->nativeScanCode() == m_repeatNativeScanCode);
+ if (keyRepeatActive) {
+ // If key repeat is active, it means we sent a synthetic key(Pressed)
to the
+ // client after the grace timer expired so that the client would do
auto-repeat.
+ //
+ // Now that the physical key is released, we will simply not handle
the release
+ // event, so it gets forwarded and the client sees the release and
stops repeating.
m_repeatNativeScanCode = 0;
+ // qCDebug(PlasmaKeyboard) << "Stopping repeat for" <<
m_repeatNativeScanCode;
+ return false;
}
// Swallow release of a discarded/committed pending key.
- // Compare by native scan code (physical key) so that modifier changes
- // between press and release don't prevent the match.
if (m_swallowNextRelease && event->nativeScanCode() ==
m_ignoreReleaseNativeScanCode) {
if (!event->isAutoRepeat()) {
// qCDebug(PlasmaKeyboard) << "Swallowing release for discarded
overlay key" << m_ignoreReleaseNativeScanCode;
@@ -225,7 +225,7 @@
}
// Handle pending key release.
- if (!m_pendingText.isEmpty() && event->nativeScanCode() ==
m_pendingNativeScanCode) {
+ if (!m_pendingText.isEmpty() && keyMatchesPending) {
// Stop timer if still active
if (m_holdTimer.isActive()) {
m_holdTimer.stop();
@@ -237,11 +237,9 @@
return true;
}
- // No overlay yet — the base character was already committed via
- // commit_string on press, so nothing to commit here. Just clear
- // pending state and consume the release (the raw press was consumed,
- // so there's no matching press on the client side).
- qCDebug(PlasmaKeyboard) << "Releasing before overlay; base character
already committed on press";
+ // The client was already sent a synthetic key press and release, so
we just need
+ // to clear pending state and consume the release (which would be
extra as far as the client is concerned).
+ qCDebug(PlasmaKeyboard) << "Releasing before overlay; key released";
resetState();
return true;
}
@@ -508,10 +506,7 @@
break;
case OverlayAction::StartTimer:
// Flush any previous pending state to prevent character drops during
- // key rollover. The old character was already committed via
- // commit_string on press, so no re-commit is needed — just mark its
- // release for swallowing (since the raw press was consumed, the client
- // never saw it, and a stray release would be unmatched).
+ // key rollover.
if (!m_pendingText.isEmpty()) {
// qCDebug(PlasmaKeyboard) << "New pending key arrived; flushing
old pending state for" << m_pendingText;
if (m_holdTimer.isActive()) {
@@ -530,39 +525,26 @@
m_holdTimer.start(result.timerDurationMs);
}
- // Immediately commit the base character via the input-method protocol
- // (commit_string). This gives zero-latency character appearance
without
- // triggering client-side key repeat (unlike forwarding the raw key).
+ // Forward the key press to the client immediately, so the client can
see the
+ // key event and insert the base character into the text field without
delay.
+ //
+ // The client will respond by inserting text and sending
surrounding_text
+ // back through the text-input protocol.
+ //
+ // Increment the echo counter and start the settle timer to prevent
this
+ // echo from being misidentified as an external cursor move (which
would cancel the overlay).
if (m_inputPlugin && !m_pendingText.isEmpty()) {
- // qCDebug(PlasmaKeyboard) << "Immediately committing base
character" << m_pendingText;
+ // qCDebug(PlasmaKeyboard) << "Forwarding key press for" <<
m_pendingText;
// The primary credit counter absorbs the first echo. The settle
// timer absorbs any additional echoes from clients that send
// multiple surrounding_text events per commit_string.
++m_pendingSurroundingTextUpdates;
m_surroundingTextSettleTimer.start();
- m_inputPlugin->commit(m_pendingText);
- }
- break;
- case OverlayAction::ConsumeEvent:
- // Commit the base character via commit_string for ordering
consistency, even
- // if the key is not a diacritic candidate.
- if (!result.commitText.isEmpty() && m_inputPlugin) {
- ++m_pendingSurroundingTextUpdates;
- m_surroundingTextSettleTimer.start();
- m_inputPlugin->commit(result.commitText);
- }
- // If the trigger requested a pending scan code, mark it for
swallowing on release.
- if (result.consumeEvent && result.pendingNativeScanCode != 0) {
- m_ignoreReleaseNativeScanCode = result.pendingNativeScanCode;
- m_swallowNextRelease = true;
- }
- // Start internal repeat timer for consumed non-diacritic keys so they
- // retain auto-repeat even though the raw key events are consumed and
don't reach the client.
- if (result.enableRepeat && result.repeatScanCode != 0) {
- m_repeatText = result.commitText;
- m_repeatNativeScanCode = result.repeatScanCode;
- // Initial delay before first repeat (matches typical XKB repeat
delay)
- m_repeatTimer.start(500);
+ m_inputPlugin->key(InputPlugin::Pressed, m_pendingNativeScanCode);
+ // We need to simulate a key release to prevent the client from
doing
+ // auto-repeat on the key. We will swallow the next release event
for this
+ // key, so the client doesn't see a double release.
+ m_inputPlugin->key(InputPlugin::Released, m_pendingNativeScanCode);
}
break;
case OverlayAction::None:
@@ -570,25 +552,6 @@
}
}
-void OverlayController::handleRepeatTimer()
-{
- if (m_repeatText.isEmpty() || !m_inputPlugin) {
- return;
- }
-
- // First tick is the initial repeat delay; switch to the shorter rate.
- if (m_repeatTimer.interval() > 100) {
- m_repeatTimer.setInterval(33); // ~30 Hz
- }
-
- ++m_pendingSurroundingTextUpdates;
- m_surroundingTextSettleTimer.start();
- m_inputPlugin->commit(m_repeatText);
-
- // The timer is single-shot; restart it for the next tick.
- m_repeatTimer.start();
-}
-
void OverlayController::handleOverlayGraceTimer()
{
// If the key was already released while the overlay was visible, don't
@@ -597,6 +560,8 @@
return;
}
+ // qCDebug(PlasmaKeyboard) << "Overlay grace timer expired; starting
repeat for" << m_pendingText;
+
// Close the overlay.
if (m_overlayVisible) {
m_overlayVisible = false;
@@ -604,14 +569,11 @@
Q_EMIT overlayClosed();
}
- // Start the internal repeat timer with the base character.
- m_repeatText = m_pendingText;
+ // Send a synthetic key press so the client will begin key repeat.
m_repeatNativeScanCode = m_pendingNativeScanCode;
- m_repeatTimer.start(500);
-
- // The raw key press was consumed, so the eventual release must be
swallowed.
- m_ignoreReleaseNativeScanCode = m_pendingNativeScanCode;
- m_swallowNextRelease = true;
+ m_inputPlugin->key(InputPlugin::Pressed, m_repeatNativeScanCode);
+ // No key release is sent here — the physical release (handled in
processKeyRelease) sends
+ // the final key(Released) to balance it.
}
void OverlayController::resetState()
@@ -619,11 +581,8 @@
if (m_holdTimer.isActive()) {
m_holdTimer.stop();
}
- m_repeatTimer.stop();
- m_repeatText.clear();
m_repeatNativeScanCode = 0;
m_overlayGraceTimer.stop();
- m_overlayGraceTimer.stop();
const bool wasVisible = m_overlayVisible;
const bool hadPending = !m_pendingText.isEmpty();
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/plasma-keyboard-6.7.1/src/overlay/overlaycontroller.h
new/plasma-keyboard-6.7.2/src/overlay/overlaycontroller.h
--- old/plasma-keyboard-6.7.1/src/overlay/overlaycontroller.h 2026-06-23
10:15:21.000000000 +0200
+++ new/plasma-keyboard-6.7.2/src/overlay/overlaycontroller.h 2026-06-30
14:34:00.000000000 +0200
@@ -189,7 +189,6 @@
private Q_SLOTS:
void handleTimerExpired();
- void handleRepeatTimer();
void handleOverlayGraceTimer();
private:
@@ -201,7 +200,6 @@
CandidateModel *m_candidateModel = nullptr;
QTimer m_holdTimer;
- QTimer m_repeatTimer;
QTimer m_overlayGraceTimer;
bool m_overlayVisible = false;
QString m_activeTriggerId;
@@ -222,12 +220,6 @@
OverlayTrigger *m_pendingTrigger = nullptr;
/**
- * Text being repeated by the internal timer for a consumed key. Empty
when no repeat
- * is active.
- */
- QString m_repeatText;
-
- /**
* Native scan code of the key currently being repeated. 0 when idle.
*/
quint32 m_repeatNativeScanCode = 0;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/plasma-keyboard-6.7.1/src/overlay/overlaytrigger.h
new/plasma-keyboard-6.7.2/src/overlay/overlaytrigger.h
--- old/plasma-keyboard-6.7.1/src/overlay/overlaytrigger.h 2026-06-23
10:15:21.000000000 +0200
+++ new/plasma-keyboard-6.7.2/src/overlay/overlaytrigger.h 2026-06-30
14:34:00.000000000 +0200
@@ -45,8 +45,6 @@
CommitText,
/** Replace surrounding text (for text expansion). */
ReplaceText,
- /** Consume the event but take no visible action. */
- ConsumeEvent,
/** Start a timer for delayed overlay activation (e.g., long-press). */
StartTimer,
};
@@ -78,25 +76,6 @@
/** For StartTimer: the pending text to be committed or shown in overlay.
*/
QString pendingText;
-
- /**
- * For ConsumeEvent: whether to enable an internal repeat timer for this
key.
- *
- * The compositor does not send auto-repeat events (state=2) to the input
- * method grab when the initial press is consumed, so keys that go through
- * the commit_string path lose native repeat. Set this to true for
printable
- * characters that should auto-repeat when held.
- */
- bool enableRepeat = false;
-
- /**
- * For ConsumeEvent: native scan code used to match the key release that
- * should stop the repeat timer.
- *
- * Same as pendingNativeScanCode but for the controller's internal repeat
- * timer rather than the long-press hold timer.
- */
- quint32 repeatScanCode = 0;
};
/**
