Fix window visibility/positioning on Windows; resolves #546

SLiMgui, upon startup, attempts to open in the same position it was last in. However, in the case of multiple screens, this may end up being off-screen (if an external monitor was removed, for example). This commit ensures that, on startup, the main window first attempts to re-open at its last location; however, if that location is off-screen, it adjusts itself to somewhere visible. It also automatically updates its position in the event the available monitors are modified (removed, adjusted, etc.). In the event an app is open in fullscreen in the space needed to open, SLiMgui will attempt to overlay that fullscreen app. If this is not possible, it will trigger an alert on the taskbar/dock, notifying the user that the app has been opened in the background.

Author: U-UMROOT\chtalbot

QtSLiM/QtSLiMAppDelegate.cpp

@@ -37,6 +37,8 @@
 #include "QtSLiMExtras.h"
 
 #include <QApplication>
+#include <QGuiApplication>
+#include <QScreen>
 #include <QOpenGLWidget>
 #include <QSurfaceFormat>
 #include <QMenu>
@@ -123,6 +125,18 @@ void QtSLiM_MessageHandler(QtMsgType type, const QMessageLogContext &context, co
     //if (msg.contains("Using QCharRef with an index"))
     //    qDebug() << "HIT WATCH MESSAGE; SET A BREAKPOINT HERE!";
 
+    // Filter known benign Windows QPA spam when displays change
+#ifdef _WIN32
+    {
+        QByteArray category = context.category ? QByteArray(context.category) : QByteArray();
+        if (category == "qwindows")
+        {
+            if (msg.startsWith("Unable to get device information for"))
+                return;
+        }
+    }
+#endif
+    
     // useful behavior, from https://doc.qt.io/qt-5/qtglobal.html#qInstallMessageHandler
     {
         QByteArray localMsg = msg.toLocal8Bit();
@@ -224,6 +238,49 @@ QtSLiMAppDelegate::QtSLiMAppDelegate(QObject *p_parent) : QObject(p_parent)
 
     // We assume we are the global instance; FIXME singleton pattern would be good
     qtSLiMAppDelegate = this;
+
+    // Ensure windows stay on-screen when displays change (added, removed, or modified)
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
+
+    // This lambda (1) ensures that visible top-level windows remain on screen;
+    // (2) raises the active window to the front on the appropriate screen, if appropriate.
+    auto ensureOnScreen = [this]() {
+        const auto topLevels = QApplication::topLevelWidgets();
+        QWidget *active = qApp->activeWindow();
+        for (QWidget *w : topLevels)
+        {
+            if (!w || !w->isWindow())
+                continue;
+            // Do not affect hidden or minimized windows; only adjust currently visible ones
+            if (!w->isVisible())
+                continue;
+            if (w->windowState() & Qt::WindowMinimized)
+                continue;
+
+            // If the window is largely off-screen after a display change, move it without forcing it to the front
+            if (QtSLiMIsMostlyOnScreen(w))
+                continue;
+
+            if (w == active)
+            {
+                // For the active window, fully expose it (bring to front)
+                QtSLiMMakeWindowVisibleAndExposed(w);
+            }
+            else
+            {
+                // For other visible windows, adjust quietly without raising
+                QtSLiMRelocateQuietly(w);
+            }
+        }
+    };
+
+    // Connect to the screenAdded, screenRemoved, and geometryChanged signals
+    // to ensure that all top-level windows are visible and exposed
+    connect(app, &QGuiApplication::screenAdded,   this, [ensureOnScreen](QScreen *) { ensureOnScreen(); });
+    connect(app, &QGuiApplication::screenRemoved, this, [ensureOnScreen](QScreen *) { ensureOnScreen(); });
+    for (QScreen *screen : QGuiApplication::screens())
+        connect(screen, &QScreen::geometryChanged, this, [ensureOnScreen](const QRect &) { ensureOnScreen(); });
+#endif
 
     // Cache app-wide icons
     slimDocumentIcon_.addFile(":/icons/DocIcon16.png");

QtSLiM/QtSLiMExtras.cpp

@@ -29,6 +29,7 @@
 #include <QSizePolicy>
 #include <QGridLayout>
 #include <QLabel>
+#include <QPointer>
 #include <QLineEdit>
 #include <QSpacerItem>
 #include <QVBoxLayout>
@@ -41,6 +42,8 @@
 #include <QApplication>
 #include <QDateTime>
 #include <QGuiApplication>
+#include <QScreen>
+#include <QWindow>
 #include <QDebug>
 #include <cmath>
 
@@ -53,6 +56,36 @@
 #include "eidos_value.h"
 
 
+bool QtSLiMIsMostlyOnScreen(QWidget *window)
+{
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
+    QRect f = window->frameGeometry();
+    QScreen *screen1 = QGuiApplication::screenAt(f.topLeft());
+    QScreen *screen2 = QGuiApplication::screenAt(f.topRight());
+    QScreen *screen3 = QGuiApplication::screenAt(f.bottomLeft());
+    QScreen *screen4 = QGuiApplication::screenAt(f.bottomRight());
+    QScreen *screen5 = QGuiApplication::screenAt(f.center());
+    int cornerCount = (!!screen1) + (!!screen2) + (!!screen3) + (!!screen4);
+    if (!screen5) cornerCount = 0;
+    return (cornerCount >= 2);
+#else
+    Q_UNUSED(window);
+    return true;
+#endif
+}
+
+void QtSLiMRelocateQuietly(QWidget *window)
+{
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
+    QScreen *primary = QGuiApplication::primaryScreen();
+    QRect avail = primary ? primary->availableGeometry() : QRect(0,0,1024,768);
+    window->resize(window->size().boundedTo(avail.size()));
+    window->move(avail.topLeft() + QPoint(50, 50));
+#else
+    Q_UNUSED(window);
+#endif
+}
+
 void QtSLiMMakeWindowVisibleAndExposed(QWidget *window)
 {
     // we've had lots of problems in SLiMgui with windows not showing when the user expects them to show; this function
@@ -67,6 +100,14 @@ void QtSLiMMakeWindowVisibleAndExposed(QWidget *window)
     // I'm not sure how this is normally dealt with by operating systems, since I never use full-screen mode
     // on macOS it seems to work OK; the new window goes full-screen also, in front of the other, which
     // I assume is the standard behavior...?  I'll wait for reported bugs on this one, I don't know.  FIXME
+
+    // Fullscreen note: on Windows, "fullscreen" often means a borderless maximized window that can be
+    // overlaid by another normal window that calls show/raise/activate. We intentionally do that here so
+    // SLiMgui presents visibly on the current screen if possible, without minimizing/altering other apps.
+    // If the window still isn't exposed (e.g., truly exclusive fullscreen), we will attempt relocation to
+    // another monitor after a short delay; if that also fails, we flash the app icon to notify the user. -Chris
+
+    // Still unclear how this will behave on Linux systems, hopefuly the same as macOS?
 
     // un-miniaturize the window if it is miniaturized
     if (window->windowState() & Qt::WindowMinimized)
@@ -77,26 +118,45 @@ void QtSLiMMakeWindowVisibleAndExposed(QWidget *window)
     window->raise();
     window->activateWindow();
 
-    // check the coordinates of the window and make sure it is actually visible on-screen
-    // This requires Qt 5.10 or later
+    // If not sufficiently visible, relocate to a safe point on the primary screen
+    if (!QtSLiMIsMostlyOnScreen(window))
+        QtSLiMRelocateQuietly(window);
+
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
-    QScreen *screen1 = QGuiApplication::screenAt(window->frameGeometry().topLeft());
-    QScreen *screen2 = QGuiApplication::screenAt(window->frameGeometry().topRight());
-    QScreen *screen3 = QGuiApplication::screenAt(window->frameGeometry().bottomLeft());
-    QScreen *screen4 = QGuiApplication::screenAt(window->frameGeometry().bottomRight());
-    QScreen *screen5 = QGuiApplication::screenAt(window->frameGeometry().center());
-    int cornerCount = (!!screen1) + (!!screen2) + (!!screen3) + (!!screen4);
-    
-    if (!screen5)
-        cornerCount = 0;
-    
-    if (cornerCount >= 2)   // 2 corners plus the center are visible
-        return;
-    
-    // we're not very visible on-screen, so move ourselves so that we are; this is obviously ungraceful
-    // it would be nice to move the window to some concept of a "closest point to the current position
-    // that is fully visible", but I'm not sure how to do that, for the general case; (100, 100) seems ok
-    window->move(100, 100);
+    // If still not actually exposed (e.g., exclusive fullscreen), re-check shortly and then try other screens
+    if (QWindow *w = window->windowHandle())
+    {
+        if (!w->isExposed())
+        {
+            QPointer<QWidget> safeWindow(window);
+            QTimer::singleShot(200, qApp, [safeWindow]() {
+                if (!safeWindow)
+                    return;
+                QWidget *win = safeWindow.data();
+                QWindow *wh = win->windowHandle();
+                if (!wh)
+                    return;
+                if (wh->isExposed())
+                    return;    // became exposed in the meantime; do nothing
+
+                QScreen *currentScreen = QGuiApplication::screenAt(win->frameGeometry().center());
+                const QList<QScreen*> screens = QGuiApplication::screens();
+                for (QScreen *screen : screens)
+                {
+                    if (screen == currentScreen)
+                        continue;
+                    QRect avail = screen->availableGeometry();
+                    win->move(avail.topLeft() + QPoint(50, 50));
+                    win->raise();
+                    win->activateWindow();
+                    if (wh->isExposed())
+                        return;
+                }
+                // If we still are not exposed anywhere, alert the user via taskbar/dock
+                qApp->alert(win);
+            });
+        }
+    }
 #endif
 }
 

QtSLiM/QtSLiMExtras.h

@@ -55,6 +55,10 @@ typedef enum {
     kBottomRight
 } QtSLiM_LegendPosition;
 
+// Utility helpers for window visibility/relocation
+bool QtSLiMIsMostlyOnScreen(QWidget *window);
+void QtSLiMRelocateQuietly(QWidget *window);
+
 void QtSLiMMakeWindowVisibleAndExposed(QWidget *window);
 
 void QtSLiMClearLayout(QLayout *layout, bool deleteWidgets = true);

QtSLiM/main.cpp

@@ -1,6 +1,7 @@
 #include "QtSLiMAppDelegate.h"
 #include "QtSLiMWindow.h"
 #include "QtSLiMPreferences.h"
+#include "QtSLiMExtras.h"
 
 #include <QApplication>
 #include <QCommandLineParser>
@@ -319,7 +320,12 @@ int main(int argc, char *argv[])
     }
 
     if (mainWin)
+    {
         mainWin->show();
+
+        // Ensures the main window is visible and exposed on startup
+        QtSLiMMakeWindowVisibleAndExposed(mainWin);
+    }
 
     appDelegate.appDidFinishLaunching(mainWin);