Auf dieser Seite

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:

QPropertyAnimation

Ö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
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

Dies ist eine Typdefinition für „ QList “ <KeyValue>

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.