fix(unitedentry): reshow popup when app regains focus

The popup is a parentless Qt::Tool window that Windows hides natively on app deactivation while United Entry stays activated, so clicking back into the input left it hidden until focus cycled through another widget.

Restore the existing popup on QGuiApplication::applicationStateChanged and on an input click via hide()+show()+raise() without calling processInput(), so an in-flight async entry (e.g. find) is not cancelled. Gate the re-map on a real deactivation (m_popupNeedsRestore) so repeated clicks while the app stays active do not flash the already-visible popup.

Author: tamlok

src/unitedentry/entrypopup.h

@@ -15,6 +15,8 @@ class EntryPopup : public QFrame {
 
   void setWidget(const QSharedPointer<QWidget> &p_widget);
 
+  bool hasWidget() const { return !m_widget.isNull(); }
+
 private:
   void takeWidget(QWidget *p_widget);
 

src/unitedentry/unitedentry.cpp

@@ -6,6 +6,7 @@
 #include <QComboBox>
 #include <QCursor>
 #include <QEvent>
+#include <QGuiApplication>
 #include <QHBoxLayout>
 #include <QKeyEvent>
 #include <QLabel>
@@ -49,6 +50,9 @@ UnitedEntry::UnitedEntry(ServiceLocator &p_services, UnitedEntryMgr *p_mgr, QWid
 
   connect(qApp, &QApplication::focusChanged, this, &UnitedEntry::handleFocusChanged);
 
+  connect(qApp, &QGuiApplication::applicationStateChanged, this,
+          &UnitedEntry::handleAppStateChanged);
+
   connect(m_mgr, &UnitedEntryMgr::entryFinished, this, &UnitedEntry::handleEntryFinished);
   connect(m_mgr, &UnitedEntryMgr::entryItemActivated, this, &UnitedEntry::handleEntryItemActivated);
 
@@ -180,6 +184,7 @@ void UnitedEntry::deactivate() {
 
   m_activated = false;
   m_previousFocusWidget = nullptr;
+  m_popupNeedsRestore = false;
 
   m_popup->hide();
   m_comboBox->lineEdit()->clearFocus();
@@ -495,6 +500,11 @@ bool UnitedEntry::eventFilter(QObject *p_watched, QEvent *p_event) {
       if (handleLineEditKeyPress(eve)) {
         return true;
       }
+    } else if (p_event->type() == QEvent::MouseButtonPress) {
+      // Returning by clicking the input keeps focus unchanged, so focusChanged
+      // never fires; re-show the popup if we are still activated. Do NOT consume
+      // the event, or the click won't position the text cursor.
+      scheduleRestorePopup();
     }
   }
 
@@ -572,6 +582,70 @@ void UnitedEntry::handleFocusChanged(QWidget *p_old, QWidget *p_now) {
   }
 }
 
+void UnitedEntry::handleAppStateChanged(Qt::ApplicationState p_state) {
+  if (p_state != Qt::ApplicationActive) {
+    // The app is deactivating; Windows hides the parentless Qt::Tool popup at
+    // the native level. Remember to re-map it when we become active again.
+    if (m_activated) {
+      m_popupNeedsRestore = true;
+    }
+    return;
+  }
+  if (!m_activated) {
+    return;
+  }
+  scheduleRestorePopup();
+}
+
+void UnitedEntry::scheduleRestorePopup() {
+  if (!m_activated || !m_popupNeedsRestore || m_restorePending) {
+    return;
+  }
+  m_restorePending = true;
+  // Defer so focus restoration / the activating click settle first.
+  QTimer::singleShot(0, this, [this]() {
+    m_restorePending = false;
+    restorePopupVisibility();
+  });
+}
+
+void UnitedEntry::restorePopupVisibility() {
+  if (!m_activated) {
+    return;
+  }
+
+  // Only restore while the input still holds focus; otherwise the normal
+  // deactivate flow in handleFocusChanged should win. Return without clearing
+  // m_popupNeedsRestore so a later trigger can retry once focus settles.
+  auto *fw = QApplication::focusWidget();
+  if (fw != m_comboBox && fw != m_comboBox->lineEdit()) {
+    return;
+  }
+
+  // Suppress when the native combo dropdown is showing history items.
+  if (m_comboBox->view()->isVisible() && m_comboBox->count() > 0) {
+    return;
+  }
+
+  m_popupNeedsRestore = false;
+
+  if (m_popup->hasWidget()) {
+    // Re-show existing content WITHOUT reprocessing, so an ongoing async entry
+    // (e.g. find) is not cancelled. Force a native re-map: Windows hides
+    // Qt::Tool windows at the native level without clearing the widget's
+    // visible state, so a plain show() can be a no-op.
+    updatePopupGeometry();
+    m_popup->hide();
+    m_popup->show();
+    m_popup->raise();
+  } else {
+    // No content yet (native dropdown suppressed the initial processInput); no
+    // entry can be ongoing here, so building content is safe.
+    m_processTimer->stop();
+    processInput();
+  }
+}
+
 void UnitedEntry::refreshIcons() {
   auto *themeService = m_services.get<ThemeService>();
   const auto fg = themeService->paletteColor("widgets#unitedentry#icon#fg");

src/unitedentry/unitedentry.h

@@ -47,6 +47,12 @@ class UnitedEntry : public QWidget {
 
   void handleFocusChanged(QWidget *p_old, QWidget *p_now);
 
+  void handleAppStateChanged(Qt::ApplicationState p_state);
+
+  void scheduleRestorePopup();
+
+  void restorePopupVisibility();
+
   const QSharedPointer<QTreeWidget> &getEntryListWidget();
 
   QSharedPointer<QLabel> getInfoWidget(const QString &p_info);
@@ -93,6 +99,13 @@ class UnitedEntry : public QWidget {
 
   bool m_deactivatePending = false;
 
+  bool m_restorePending = false;
+
+  // Set only when the app is deactivated while activated (the OS natively hides
+  // the Qt::Tool popup). Gates the re-map restore so repeated clicks while the
+  // app stays active do not needlessly hide/show the already-visible popup.
+  bool m_popupNeedsRestore = false;
+
   QWidget *m_previousFocusWidget = nullptr;
 
   QTimer *m_processTimer = nullptr;