Reduce the requirements of unnecessary key event forwarding.

In a previous fix of keyboard engine, update preedit to empty is commonly done
to ensure there is nothing in the preedit. This introduces some empty
update preedit for keyboard engine and uses the code path for key event
order fix. This makes almost all key event need to be re-forwarded,
which is unnecssary.

Add a new helper function to check if the strict order matters:
1. all pending events are update preedit.
2. preedit is empty.

If above condition satisfies and we don't need to need forward the key,
allow it to be handled out of order.

Attempt Fix #702

Author: wengxt

src/lib/fcitx/inputcontext.cpp

@@ -329,6 +329,27 @@ bool InputContext::hasPendingEvents() const {
     return !d->blockedEvents_.empty();
 }
 
+bool InputContext::hasPendingEventsStrictOrder() const {
+    FCITX_D();
+    if (d->blockedEvents_.empty()) {
+        return false;
+    }
+
+    // Check we only have update preedit.
+    if (std::any_of(d->blockedEvents_.begin(), d->blockedEvents_.end(),
+                    [](const auto &event) {
+                        return event->type() !=
+                               EventType::InputContextUpdatePreedit;
+                    })) {
+        return false;
+    }
+
+    // Check whether the preedit is non-empty.
+    // If key event may produce anything, it still may trigger the clear
+    // preedit. In that case, preedit order does matter.
+    return !inputPanel().clientPreedit().toString().empty();
+}
+
 void InputContext::commitString(const std::string &text) {
     FCITX_D();
     if (auto *instance = d->manager_.instance()) {
@@ -367,11 +388,21 @@ InputPanel &InputContext::inputPanel() {
     return d->inputPanel_;
 }
 
+const InputPanel &InputContext::inputPanel() const {
+    FCITX_D();
+    return d->inputPanel_;
+}
+
 StatusArea &InputContext::statusArea() {
     FCITX_D();
     return d->statusArea_;
 }
 
+const StatusArea &InputContext::statusArea() const {
+    FCITX_D();
+    return d->statusArea_;
+}
+
 void InputContext::updateClientSideUIImpl() {}
 
 InputContextEventBlocker::InputContextEventBlocker(InputContext *inputContext)

src/lib/fcitx/inputcontext.h

@@ -207,6 +207,16 @@ class FCITXCORE_EXPORT InputContext : public TrackableObject<InputContext> {
     void setBlockEventToClient(bool block);
     bool hasPendingEvents() const;
 
+    /**
+     * Has pending event that need to use key order fix.
+     *
+     * If pending event only have preedit, then it's generally fine to not use
+     * key forward.
+     *
+     * @since 5.0.21
+     */
+    bool hasPendingEventsStrictOrder() const;
+
     /// Returns the input context property by name.
     InputContextProperty *property(const std::string &name);
 
@@ -216,9 +226,23 @@ class FCITXCORE_EXPORT InputContext : public TrackableObject<InputContext> {
     /// Returns the associated input panel.
     InputPanel &inputPanel();
 
+    /**
+     * Returns the associated input panel.
+     *
+     * @since 5.0.22
+     */
+    const InputPanel &inputPanel() const;
+
     /// Returns the associated StatusArea.
     StatusArea &statusArea();
 
+    /**
+     * Returns the associated StatusArea.
+     *
+     * @since 5.0.22
+     */
+    const StatusArea &statusArea() const;
+
     /**
      * Helper function to return the input context property in specific type.
      *

src/lib/fcitx/instance.cpp

@@ -1443,9 +1443,8 @@ bool Instance::postEvent(Event &event) const {
                                                           : XKB_KEY_DOWN);
             } while (0);
 #endif
-            if (ic->hasPendingEvents() &&
-                ic->capabilityFlags().test(CapabilityFlag::KeyEventOrderFix) &&
-                !keyEvent.accepted()) {
+            if (ic->capabilityFlags().test(CapabilityFlag::KeyEventOrderFix) &&
+                !keyEvent.accepted() && ic->hasPendingEventsStrictOrder()) {
                 // Re-forward the event to ensure we got delivered later than
                 // commit.
                 keyEvent.filterAndAccept();