Optimizing Qt Applications for Different Screens with QWindow::screenChanged()

Purpose

• The QWindow::screenChanged() signal is emitted by a QWindow object whenever the screen it's associated with changes. This can occur due to various reasons, such as:
  • The window being moved to a different physical display.
  • The configuration of the display device changing (e.g., resolution or orientation).
  • The window being attached to a different virtual screen (in multi-screen setups).

Functionality

• When the signal is emitted, it passes a pointer to the new QScreen object as an argument to the connected slots. This allows your application to react to the screen change and potentially adapt its behavior or appearance.

Common Use Cases

• Optimizing for Different Screens
  If your application needs to handle different screen types (e.g., touchscreens, high-resolution displays), you can use screenChanged() to detect the screen type and tailor your UI elements or interactions for best user experience on that particular screen.
• Adjusting Window Properties
  Certain window properties, like scaling or high-DPI settings, might be relevant to the specific screen. You can use screenChanged() to query the new screen's capabilities and adjust your window's properties accordingly.
• Updating Window Geometry
  If your application relies on specific screen dimensions or positions, you can use screenChanged() to recalculate the window's geometry based on the new screen information. This can help maintain proper window placement and avoid issues if the screen configuration changes.

Connecting to the Signal

• To connect a slot to the screenChanged() signal, you can use the Qt's QObject::connect() function:

connect(myWindow, &QWindow::screenChanged, this, &MyClass::onScreenChanged);

In this example, myWindow is a pointer to your QWindow object, and onScreenChanged is a slot function in your class that will be invoked when the screen changes.

Example Implementation

#include <QApplication>
#include <QMainWindow>
#include <QScreen>

class MyWindow : public QMainWindow {
    Q_OBJECT

public:
    MyWindow(QWidget *parent = nullptr);

private slots:
    void onScreenChanged(QScreen *newScreen);

signals:
    void screenGeometryChanged(const QRect &geometry);

private:
    QRect windowGeometry;
};

MyWindow::MyWindow(QWidget *parent) : QMainWindow(parent) {
    connect(this, &QWindow::screenChanged, this, &MyWindow::onScreenChanged);
    // ... (other window setup)
}

void MyWindow::onScreenChanged(QScreen *newScreen) {
    windowGeometry = geometry(); // Get current geometry

    // Update window properties based on new screen information
    if (newScreen->isHighResolution()) {
        // Adjust scaling or other properties for high-resolution screens
        ...
    }

    // Reposition or resize window if necessary
    if (windowGeometry.bottomRight() > newScreen->availableGeometry().bottomRight()) {
        // Window extends beyond new screen; adjust position or size
        ...
    }

    emit screenGeometryChanged(geometry()); // Signal geometry change
}

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    MyWindow window;
    window.show();
    return app.exec();
}

• If you don't need to perform any specific actions, you can simply connect the signal to an empty slot to acknowledge the notification.
• The specific actions you take in the slot function will depend on your application's requirements and how you want it to adapt to screen changes.
• Remember to handle potential null pointer issues when checking the received QScreen object in your slot function.

---

Updating Window Title with Screen Resolution

This example shows how to update the window title to display the current screen resolution whenever the screen changes.

#include <QApplication>
#include <QMainWindow>
#include <QScreen>

class MyWindow : public QMainWindow {
    Q_OBJECT

public:
    MyWindow(QWidget *parent = nullptr);

private slots:
    void onScreenChanged(QScreen *newScreen);

private:
    QString windowTitle;
};

MyWindow::MyWindow(QWidget *parent) : QMainWindow(parent) {
    connect(this, &QWindow::screenChanged, this, &MyWindow::onScreenChanged);
    windowTitle = QString("My Window");
    setWindowTitle(windowTitle);
}

void MyWindow::onScreenChanged(QScreen *newScreen) {
    const QSize screenSize = newScreen->size();
    windowTitle = QString("My Window (%1x%2)").arg(screenSize.width()).arg(screenSize.height());
    setWindowTitle(windowTitle);
}

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    MyWindow window;
    window.show();
    return app.exec();
}

Optimizing UI for Touchscreens

This example demonstrates how to detect a touchscreen and adjust the size of buttons for better touch interaction when the screen changes.

#include <QApplication>
#include <QMainWindow>
#include <QScreen>
#include <QPushButton>

class MyWindow : public QMainWindow {
    Q_OBJECT

public:
    MyWindow(QWidget *parent = nullptr);

private slots:
    void onScreenChanged(QScreen *newScreen);

private:
    QPushButton *button;
};

MyWindow::MyWindow(QWidget *parent) : QMainWindow(parent) {
    connect(this, &QWindow::screenChanged, this, &MyWindow::onScreenChanged);

    button = new QPushButton("Click Me", this);
    button->show();  // ... (other window setup)
}

void MyWindow::onScreenChanged(QScreen *newScreen) {
    if (newScreen->capabilities().testFlag(QScreen::Capability::Touch)) {
        // Adjust button size for better touch interaction on touchscreens
        button->setFixedSize(100, 50);  // Adjust size as needed
    }
}

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    MyWindow window;
    window.show();
    return app.exec();
}

---

QGuiApplication::primaryScreenChanged()

• Drawback
  It won't detect changes where the window moves to a different non-primary screen.
• This signal is emitted by the QGuiApplication object whenever the primary screen changes. This can be useful if you only care about the primary screen and don't need to track changes for all connected screens.

QResizeEvent

• Drawbacks
  
  • It might fire for other reasons besides screen changes (e.g., window resizing within the same screen).
  • Requires additional logic to compare geometries.
• This event is emitted by a QWidget object whenever its size is changed. While it doesn't directly indicate a screen change, you can use the new size information along with QApplication::desktop()->screenGeometry(this) to check if the window has moved to a different screen based on its geometry relative to the available screen geometries.

Platform-Specific APIs

• For more granular control over screen change detection, you might explore platform-specific APIs like those available on Windows (WM_DISPLAYCHANGE message) or Linux (X11 RandR extension). However, this approach introduces platform dependence and requires additional coding for different operating systems.

Choosing the Right Approach

The best alternative depends on your specific requirements:

• If you need the most control and are willing to handle platform-specific code, platform APIs might be an option.
• If you need to detect any screen change (including moving to a non-primary screen) and are comfortable with additional logic, QResizeEvent combined with geometry checks can work.
• If you only need to react to changes in the primary screen, QGuiApplication::primaryScreenChanged() can be sufficient.

• Evaluate your specific needs and choose the approach that best suits your application's requirements and complexity.
• In most cases, QWindow::screenChanged() offers a good balance between ease of use and functionality. It covers most common screen change scenarios without requiring complex platform-specific code.