Unfortunately, with all the normal magic of QML property bindings, getting a property updated in a setup that involves return values from functions isn’t really doable, like this:
|
1 2 3 |
Text { text: qtobject.calculatedValue() } |
I’m told there is a low priority feature request for a way of signalling that a function now returns a different value and all properties using it should be reevaluated.
I have so far discovered two different workarounds for that that I will be presenting here.
Using an extra property
Appending an extra property to trigger the reevaluation of the function is one way of doing it.
|
1 2 3 |
Text { text: qtobject.calculatedValue() + qtobject.emptyNotifierThing } |
with the following on the C++ side:
|
1 2 3 4 |
Q_PROPERTY(QString emptyNotifierThing READ emptyString NOTIFY valueChanged) QString emptyString() const { return QString(); } |
This is a bit more code to write and to remember to use, but it does get the job done.
Intermediate layer
Another way is to inject an intermediate layer, an extra object, that has the function. It can even be simplified by having a pointer to itself.
|
1 2 3 |
Text { text: qtobject.dataAccess.calculatedValue() } |
with the following on the C++ side:
|
1 2 3 4 |
Q_PROPERTY(QObject* dataAccess READ dataAccess NOTIFY valueChanged) QObject* dataAccess() { return this; } |
It seems a bit simpler for the reader on the QML side, but also gets the job done.
I am not sure which way is the best one, but the intermediate layer has a nicer feeling to it when more complicated types are involved.
Isn’t this was read-only properties are for? To me, an invokable is something that you call from a piece of Javascript in an imperative way.
Right, I think in this case you should try to turn this into a property. Functions which do not require arguments are suitable.
With function carrying args, however, this “extra property trick” might be useful. Consider the following use-case:
Image { id: someIcon; source: ThemeObject.fromTheme(“someIcon”) }
ThemeObject is a QObject-based class for managing the current theme. ThemeObject::fromTheme(QString iconName) is Q_INVOKABLE function returning an icon based on the iconName and depending on the current theme. The icon name in this example is constant, we don’t care about that. But when the current theme changes we’d like ThemeObject.fromTheme(..) to be re-evaluated. Further assume there’s a ThemeObject::currentTheme property for the current theme.
How to do that?
=> Create a wrapper function in QML/JS which has a property binding on both the icon name and the current theme.
function customFromTheme(icon)
{
/* no-op for keeping a binding on this property */
ThemeObject.currentTheme
return ThemeObject.fromTheme(icon)
}
Now the initial example turns into:
Image { id: someIcon; source: customFromTheme(“someIcon”) }
=> Works as expected, customFromTheme(..) is re-evaluated when the theme changes