Qt 5.9.3中如何追踪Item首次在应用窗口的可见性？

Hey there! Let's break down your question into two clear parts: handling standard QML Items and custom MyQuickItem components, tailored specifically for your Qt 5.9.3 setup.

For Standard QML Items #

First, let's clear up a common confusion between two related properties—this is crucial for getting accurate visibility tracking:

• visibility: An enum (Visible, Hidden, Collapsed) that only controls the item's own visibility state, ignoring parent items. So onVisibilityChanged triggers when this enum changes, but it doesn't guarantee the item is actually visible on screen (e.g., if a parent is hidden, the child won't show even if its visibility is Visible).
• visible: A boolean that accounts for the entire parent chain—it's only true if the item and all its ancestors are visible. This is the property you want to track for actual on-screen visibility.

To catch the first time the item becomes visible on screen:

1. Add a flag to avoid triggering the logic multiple times.
2. Use onVisibleChanged to check when the item becomes visible and hasn't been marked as seen before.

Example code:

Item {
    // Flag to prevent repeated triggers
    property bool hasBeenVisible: false

    onVisibleChanged: {
        if (visible && !hasBeenVisible) {
            hasBeenVisible = true;
            console.log("Standard Item is now first visible on screen!");
            // Run your custom logic here
        }
    }
}

If you also need to ensure the item is within the window's visible area (not just parent-visible but off-screen), you can add an extra check using mapToGlobal to compare the item's global bounds with the window's geometry. For most use cases though, the visible property check is sufficient.

For Custom MyQuickItem (C++ QQuickItem Subclass) #

For custom components, you'll implement the tracking logic in C++ to get full control over the item's state. Here's a step-by-step approach:

Step 1: Add Tracking Logic in C++ #

We'll listen to all signals that affect visibility, verify if the item is actually visible on screen, and emit a custom signal when it first becomes visible.

#include <QQuickItem>
#include <QQuickWindow>

class MyQuickItem : public QQuickItem
{
    Q_OBJECT
public:
    explicit MyQuickItem(QQuickItem *parent = nullptr) 
        : QQuickItem(parent)
    {
        // Listen to signals that could alter visibility status
        connect(this, &QQuickItem::visibleChanged, this, &MyQuickItem::checkFirstVisible);
        connect(this, &QQuickItem::xChanged, this, &MyQuickItem::checkFirstVisible);
        connect(this, &QQuickItem::yChanged, this, &MyQuickItem::checkFirstVisible);
        connect(this, &QQuickItem::widthChanged, this, &MyQuickItem::checkFirstVisible);
        connect(this, &QQuickItem::heightChanged, this, &MyQuickItem::checkFirstVisible);
        
        // Track window geometry changes (in case the window moves/resizes)
        connect(this, &QQuickItem::windowChanged, this, [this](QQuickWindow *window) {
            if (window) {
                connect(window, &QQuickWindow::geometryChanged, this, &MyQuickItem::checkFirstVisible);
            }
        });
    }

signals:
    // Custom signal to notify QML when the item is first visible
    void firstVisible();

private slots:
    void checkFirstVisible() {
        // Exit if we've already detected the first visibility
        if (m_firstVisible) return;

        // Check if the item is visible (accounts for parent chain)
        if (!isVisible()) return;

        QQuickWindow *window = this->window();
        if (!window) return;

        // Convert item's local bounds to global screen coordinates
        QRectF itemGlobalRect = mapRectToGlobal(boundingRect());
        QRect windowScreenRect = window->geometry();

        // Verify the item overlaps with the window's visible area
        if (itemGlobalRect.intersects(windowScreenRect)) {
            m_firstVisible = true;
            emit firstVisible();
            // Execute any C++ side logic here if needed
        }
    }

private:
    bool m_firstVisible = false;
};

Step 2: Use the Custom Signal in QML #

After registering your custom component with QML, you can listen to the firstVisible signal directly:

MyQuickItem {
    onFirstVisible: {
        console.log("Custom MyQuickItem is now first visible on screen!");
        // Your QML logic here
    }
}

Key Notes #

• If you don't care about the item being within the window's bounds (only that it's parent-visible), you can simplify the C++ logic to just check isVisible() without the geometry intersection check.
• Qt 5.9.3 lacks some newer visibility APIs (like QQuickItem::isVisibleInWindow()), so the above approach is fully compatible with your version.

内容的提问来源于stack exchange，提问作者TheWaterProgrammer