QVariantAnimation Class
Die Klasse „QVariantAnimation“ dient als Basisklasse für Animationen. Mehr...
| Header: | #include <QVariantAnimation> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Erbt von: | QAbstractAnimation |
| Vererbt an: |
- Liste aller Mitglieder, einschließlich geerbter Mitglieder
- QVariantAnimation ist Teil des Animations-Frameworks.
Öffentliche Typen
Eigenschaften
|
|
Öffentliche Funktionen
| QVariantAnimation(QObject *parent = nullptr) | |
| virtual | ~QVariantAnimation() |
| QBindable<int> | bindableDuration() |
| QBindable<QEasingCurve> | bindableEasingCurve() |
| QVariant | currentValue() const |
| QEasingCurve | easingCurve() const |
| QVariant | endValue() const |
| QVariant | keyValueAt(qreal step) const |
| QVariantAnimation::KeyValues | keyValues() const |
| void | setDuration(int msecs) |
| void | setEasingCurve(const QEasingCurve &easing) |
| void | setEndValue(const QVariant &value) |
| void | setKeyValueAt(qreal step, const QVariant &value) |
| void | setKeyValues(const QVariantAnimation::KeyValues &keyValues) |
| void | setStartValue(const QVariant &value) |
| QVariant | startValue() const |
Neu implementierte öffentliche Funktionen
| virtual int | duration() const override |
Signale
| void | valueChanged(const QVariant &value) |
Geschützte Funktionen
| virtual QVariant | interpolated(const QVariant &from, const QVariant &to, qreal progress) const |
| virtual void | updateCurrentValue(const QVariant &value) |
Neu implementierte geschützte Funktionen
| virtual bool | event(QEvent *event) override |
| virtual void | updateCurrentTime(int) override |
| virtual void | updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) override |
Zugehörige Nicht-Mitglieder
| void | qRegisterAnimationInterpolator(QVariant (*func)(const T &, const T &, qreal)) |
Ausführliche Beschreibung
Diese Klasse ist Teil des Animation Framework. Sie dient als Basisklasse für Eigenschafts- und Elementanimationen und enthält Funktionen für gemeinsam genutzte Funktionalitäten.
Die Klasse führt eine Interpolation über „ QVariant“ durch, überlässt jedoch die Verwendung der interpolierten Werte ihren Unterklassen. Derzeit stellt Qt die Klasse „ QPropertyAnimation “ bereit, die Qt-Eigenschaften animiert. Lesen Sie die Klassenbeschreibung von „ QPropertyAnimation “, wenn Sie solche Eigenschaften animieren möchten.
Sie können dann Start- und Endwerte für die Eigenschaft festlegen, indem Sie ` setStartValue()` und ` setEndValue()` aufrufen, und schließlich ` start()` aufrufen, um die Animation zu starten. `QVariantAnimation` interpoliert die Eigenschaft des Zielobjekts und sendet das Signal ` valueChanged()`. Um auf eine Änderung des aktuellen Werts zu reagieren, müssen Sie die virtuelle Funktion ` updateCurrentValue()` neu implementieren oder eine Verbindung zu diesem Signal herstellen.
Es ist auch möglich, Werte an bestimmten Schritten zwischen dem Start- und Endwert festzulegen. Die Interpolation durchläuft dann diese Punkte an den angegebenen Schritten. Beachten Sie, dass der Start- und Endwert als Schlüsselwerte bei 0,0 und 1,0 definiert sind.
Es gibt zwei Möglichkeiten, die Art und Weise zu beeinflussen, wie `QVariantAnimation` die Werte interpoliert. Sie können eine Beschleunigungskurve festlegen, indem Sie ` setEasingCurve()` aufrufen, und die Dauer konfigurieren, indem Sie ` setDuration()` aufrufen. Sie können die Art und Weise ändern, wie die ` QVariant`-Werte interpoliert werden, indem Sie eine Unterklasse von `QVariantAnimation` erstellen und die virtuelle Funktion ` interpolated()` neu implementieren.
Die Erstellung einer Unterklasse von `QVariantAnimation` kann eine Alternative sein, wenn Sie ` QVariant` haben, die Sie nicht als Qt-Eigenschaften deklarieren möchten. Beachten Sie jedoch, dass es in den meisten Fällen besser ist, Ihre ` QVariant ` als Eigenschaften zu deklarieren.
Es werden nicht alle „ QVariant “-Typen unterstützt. Nachfolgend finden Sie eine Liste der derzeit unterstützten „ QVariant “-Typen:
Wenn Sie andere „Variant“-Typen, einschließlich benutzerdefinierter Typen, interpolieren müssen, müssen Sie die Interpolation hierfür selbst implementieren. Dazu können Sie eine Interpolationsfunktion für einen bestimmten Typ registrieren. Diese Funktion nimmt drei Parameter entgegen: den Startwert, den Endwert und den aktuellen Fortschritt.
Beispiel:
QVariant myColorInterpolator(const QColor&start, const QColor&end, qreal progress)
{
// ...
return QColor(/*...*/);
}
// ...
void someFunc()
{
// ...
qRegisterAnimationInterpolator<QColor>(myColorInterpolator);
// ...
}Eine weitere Möglichkeit besteht darin, ` interpolated()` neu zu implementieren, wodurch Interpolationswerte für den zu interpolierenden Wert zurückgegeben werden.
Siehe auch QPropertyAnimation, QAbstractAnimation und „The Animation Framework“.
Dokumentation zu Mitgliedstypen
[alias] QVariantAnimation::KeyValue
Dies ist ein `typedef` für `std::pair<qreal, QVariant>`.
QVariantAnimation::KeyValues
Dokumentation zu den Eigenschaften
[read-only] currentValue : QVariant
Diese Eigenschaft enthält den aktuellen Wert der Animation.
Diese Eigenschaft beschreibt den aktuellen Wert – einen interpolierten Wert zwischen ` start value ` und ` end value`, wobei die aktuelle Zeit als Fortschrittswert verwendet wird. Der Wert selbst wird von ` interpolated()` ermittelt, das während der Ausführung der Animation wiederholt aufgerufen wird.
QVariantAnimation ruft die virtuelle Funktion ` updateCurrentValue()` auf, wenn sich der aktuelle Wert ändert. Dies ist besonders nützlich für Unterklassen, die Aktualisierungen verfolgen müssen. Beispielsweise verwendet ` QPropertyAnimation ` diese Funktion, um Qt-Eigenschaften zu animieren.
Zugriffsfunktionen:
| QVariant | currentValue() const |
Notifier-Signal:
| void | valueChanged(const QVariant &value) |
Siehe auch „ startValue “ und „ endValue “.
[bindable] duration : int
Hinweis: Diese Eigenschaft unterstützt Bindungen im Format „ QProperty “.
Diese Eigenschaft gibt die Dauer der Animation an
Diese Eigenschaft beschreibt die Dauer der Animation in Millisekunden. Die Standarddauer beträgt 250 Millisekunden.
Zugriffsfunktionen:
| virtual int | duration() const override |
| void | setDuration(int msecs) |
Siehe auch „ QAbstractAnimation::duration()“.
[bindable] easingCurve : QEasingCurve
Hinweis: Diese Eigenschaft unterstützt „ QProperty “-Bindungen.
Diese Eigenschaft enthält die Beschleunigungskurve der Animation
Diese Eigenschaft definiert die Beschleunigungskurve der Animation. Standardmäßig wird eine lineare Beschleunigungskurve verwendet, was zu einer linearen Interpolation führt. Es stehen weitere Kurven zur Verfügung, beispielsweise „ QEasingCurve::InCirc “, die eine kreisförmige Einstiegskurve bietet. Ein weiteres Beispiel ist „ QEasingCurve::InOutElastic “, die einen elastischen Effekt auf die Werte der interpolierten Variante erzeugt.
QVariantAnimation verwendet die Funktion „ QEasingCurve::valueForProgress()“, um den „normalisierten Fortschritt“ (currentTime() / totalDuration()) der Animation in den effektiven Fortschritt umzuwandeln, der tatsächlich von der Animation verwendet wird. Dieser effektive Fortschritt ist der Fortschritt, der beim Aufruf von „ interpolated()“ verwendet wird. Auch die Schritte in der Funktion „ keyValues “ beziehen sich auf diesen effektiven Fortschritt.
Die Easing-Kurve wird zusammen mit dem Interpolator, der virtuellen Funktion ` interpolated()` und der Dauer der Animation verwendet, um zu steuern, wie sich der aktuelle Wert im Verlauf der Animation ändert.
Zugriffsfunktionen:
| QEasingCurve | easingCurve() const |
| void | setEasingCurve(const QEasingCurve &easing) |
endValue : QVariant
Diese Eigenschaft enthält den Endwert der Animation
Diese Eigenschaft beschreibt den Endwert der Animation.
Zugriffsfunktionen:
| QVariant | endValue() const |
| void | setEndValue(const QVariant &value) |
Siehe auch „ startValue “.
startValue : QVariant
Diese Eigenschaft enthält den optionalen Startwert der Animation
Diese Eigenschaft beschreibt den optionalen Startwert der Animation. Wird sie weggelassen oder als Startwert eine Null QVariant zugewiesen, verwendet die Animation beim Start die aktuelle Endposition.
Zugriffsfunktionen:
| QVariant | startValue() const |
| void | setStartValue(const QVariant &value) |
Siehe auch „ endValue “.
Dokumentation zu den Member-Funktionen
QVariantAnimation::QVariantAnimation(QObject *parent = nullptr)
Erstellen Sie ein `QVariantAnimation`-Objekt. ` parent ` wird an den Konstruktor von ` QAbstractAnimation` übergeben.
[virtual noexcept] QVariantAnimation::~QVariantAnimation()
Löscht die Animation.
[override virtual protected] bool QVariantAnimation::event(QEvent *event)
Umsetzt: ` QAbstractAnimation::event(QEvent *event)`.
[virtual protected] QVariant QVariantAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const
Diese virtuelle Funktion gibt die lineare Interpolation zwischen den Varianten from und to am Punkt progress zurück, in der Regel einen Wert zwischen 0 und 1. Sie können diese Funktion in einer Unterklasse von QVariantAnimation neu implementieren, um einen eigenen Interpolationsalgorithmus bereitzustellen.
Beachten Sie, dass die Interpolation nur dann mit einem ` QEasingCurve ` funktioniert, der einen Wert kleiner als 0 oder größer als 1 zurückgibt (wie z. B. ` QEasingCurve::InBack`), wenn sichergestellt ist, dass eine Extrapolation möglich ist. Wenn die Semantik des Datentyps keine Extrapolation zulässt, sollte diese Funktion dies elegant handhaben.
Sie sollten die ` QVariantAnimation `-Implementierung dieser Funktion aufrufen, wenn Ihre Klasse die von Qt bereits unterstützten Typen verarbeiten soll (eine Liste der unterstützten Typen finden Sie in der Beschreibung der Klasse ` QVariantAnimation `).
Siehe auch QEasingCurve.
QVariant QVariantAnimation::keyValueAt(qreal step) const
Gibt den Keyframe-Wert für das angegebene „ step “ zurück. Das angegebene „ step “ muss im Bereich von 0 bis 1 liegen. Wenn für „ step “ kein „ KeyValue “ vorhanden ist, wird ein ungültiges „ QVariant “ zurückgegeben.
Siehe auch keyValues() und setKeyValueAt().
QVariantAnimation::KeyValues QVariantAnimation::keyValues() const
Gibt die Schlüsselbilder dieser Animation zurück.
Siehe auch keyValueAt() und setKeyValues().
void QVariantAnimation::setKeyValueAt(qreal step, const QVariant &value)
Erstellt einen Keyframe bei der angegebenen Koordinate step mit dem angegebenen Wert value. Der angegebene Wert step muss im Bereich von 0 bis 1 liegen.
Siehe auch setKeyValues() und keyValueAt().
void QVariantAnimation::setKeyValues(const QVariantAnimation::KeyValues &keyValues)
Ersetzt die aktuellen Keyframes durch die angegebenen keyValues. Der Schritt der Keyframes muss im Bereich von 0 bis 1 liegen.
Siehe auch „ keyValues()“ und „ keyValueAt()“.
[override virtual protected] void QVariantAnimation::updateCurrentTime(int)
Implementiert: QAbstractAnimation::updateCurrentTime(int currentTime).
[virtual protected] void QVariantAnimation::updateCurrentValue(const QVariant &value)
Diese virtuelle Funktion wird jedes Mal aufgerufen, wenn sich der aktuelle Wert der Animation ändert. Das Argument „ value “ ist der neue aktuelle Wert.
Die Implementierung der Basisklasse führt keine Aktion aus.
Siehe auch ` currentValue`.
[override virtual protected] void QVariantAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
Implementiert: QAbstractAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState).
[signal] void QVariantAnimation::valueChanged(const QVariant &value)
QVariantAnimation gibt dieses Signal aus, sobald sich der aktuelle Wert von ` value ` ändert.
Hinweis: Notifier -Signal für die Eigenschaft „ currentValue “.
Siehe auch „ currentValue “, „ startValue “ und „ endValue “.
Verwandte Nicht-Mitglieder
template <typename T> void qRegisterAnimationInterpolator(QVariant (*func)(const T &, const T &, qreal))
Registriert einen benutzerdefinierten Interpolator „ func “ für den Vorlagentyp „ T “. Der Interpolator muss vor der Erstellung der Animation registriert werden. Um die Registrierung aufzuheben (und den Standard-Interpolator zu verwenden), setzen Sie „ func “ auf „ nullptr “.
Warnung: Das Registrieren eines benutzerdefinierten Interpolators für einen der in Qt integrierten Typen (z. B. int) wirkt sich auf alle Animationen dieses Typs aus, die später erstellt werden. Dies kann unerwünscht sein. Es wird daher empfohlen, den Interpolator nach der Erstellung der gewünschten Animationen auf den Standardwert zurückzusetzen.
Hinweis: Diese Funktion ist threadsicher.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.