如何连接两个QQuickPaintedItem派生类？是否可实现及方法？

Absolutely doable! Since both QlLinePlotItem and WaterfallItem inherit from QQuickPaintedItem—which is a subclass of QObject—they’re fully compatible with Qt’s signal-slot mechanism. Below are the most practical ways to wire them up, depending on where your instances are created:

1. Connect Directly in C++ #

If you’re instantiating both objects in C++ code, you can use the classic QObject::connect() method. This is straightforward if you have pointers to both instances:

// Assume you have valid instances of both classes
QlLinePlotItem* linePlot = new QlLinePlotItem();
WaterfallItem* waterfall = new WaterfallItem();

// Replace `yourSignal` and `yourSlot` with your actual signal/slot names
// Ensure their parameter types match exactly (slot can have fewer params than signal, but types must align)
connect(linePlot, &QlLinePlotItem::yourSignal, 
        waterfall, &WaterfallItem::yourSlot);

Key Notes for C++ Connections: #

• Make sure both classes include the Q_OBJECT macro in their declarations, and that you’ve run qmake/CMake’s AUTOMOC to generate the necessary meta-object code.
• Signal and slot signatures must be compatible: if your signal is void dataUpdated(QVector<float> newData), your slot can be void processNewData(QVector<float> data) (matching types) or even void handleUpdate() (no params, if you don’t need the data).

2. Connect in QML #

Since you’ve already registered both types with qmlRegisterType, connecting them in QML is often the most convenient approach for Qt Quick applications. There are two common patterns here:

Option A: Direct Signal Handler in the Sender #

You can define the signal handler directly inside your QlLinePlotItem instance, then call the receiver’s slot:

QlLinePlotItem {
    id: linePlot
    // Replace `onYourSignal` with your signal name (capitalized first letter after "on")
    onYourSignal: {
        // Call the slot on your WaterfallItem instance
        waterfall.yourSlot(/* pass any required arguments here */)
    }
}

WaterfallItem {
    id: waterfall
}

Option B: Use the Connections Component #

This is useful if you want to separate the connection logic from the sender, or if the two items aren’t in a parent-child hierarchy:

QlLinePlotItem {
    id: linePlot
}

WaterfallItem {
    id: waterfall
}

// The Connections component lets you listen to signals from a target object
Connections {
    target: linePlot
    onYourSignal: {
        waterfall.yourSlot(/* pass arguments if needed */)
    }
}

Key Notes for QML Connections: #

• For your slot to be callable from QML, it must either be declared with Q_SLOTS (or slots: in older Qt syntax) or marked with Q_INVOKABLE in the C++ class definition.
• Signals don’t need extra setup beyond being declared with Q_SIGNALS (or signals:) in C++—they’ll be automatically accessible in QML as on<SignalName> handlers.

3. Property Binding (For Property-Driven Updates) #

If your signal is tied to a property change (e.g., a dataChanged signal emitted when a plotData property updates), you can skip explicit signal-slot connections and use Qt’s property binding system:

QlLinePlotItem {
    id: linePlot
    // Assume `plotData` is a Q_PROPERTY with NOTIFY signal
}

WaterfallItem {
    id: waterfall
    // Bind waterfall's input property to linePlot's data property
    inputData: linePlot.plotData
}

This will automatically update waterfall.inputData whenever linePlot.plotData changes (as long as the plotData property has a corresponding notify signal).

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