QVariantAnimation Class

Die Klasse QVariantAnimation bietet eine Basisklasse für Animationen. Mehr...

Kopfzeile: #include <QVariantAnimation>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Vererbt: QAbstractAnimation
Vererbt von:

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

Reimplementierte ö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)

Reimplementierte 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 (*)(const T &, const T &, qreal) func)

Detaillierte Beschreibung

Diese Klasse ist Teil des The Animation Framework. Sie dient als Basisklasse für Eigenschafts- und Elementanimationen, mit Funktionen für gemeinsame Funktionalität.

Die Klasse führt eine Interpolation über QVariants durch, überlässt aber die Verwendung der interpolierten Werte ihren Unterklassen. Derzeit bietet Qt die Klasse QPropertyAnimation, die Qt-Eigenschaften animiert. Siehe die Beschreibung der Klasse QPropertyAnimation, wenn Sie solche Eigenschaften animieren möchten.

Sie können dann Start- und Endwerte für die Eigenschaft setzen, indem Sie setStartValue() und setEndValue() aufrufen, und schließlich start() aufrufen, um die Animation zu starten. QVariantAnimation wird die Eigenschaft des Zielobjekts interpolieren und valueChanged() ausgeben. Um auf eine Änderung des aktuellen Wertes zu reagieren, müssen Sie die virtuelle Funktion updateCurrentValue() neu implementieren oder sich mit diesem Signal verbinden.

Es ist auch möglich, Werte in bestimmten Schritten zu setzen, die zwischen dem Start- und Endwert liegen. Die Interpolation berührt dann diese Punkte in den angegebenen Schritten. Beachten Sie, dass die Start- und Endwerte als Schlüsselwerte bei 0,0 und 1,0 definiert sind.

Es gibt zwei Möglichkeiten zu beeinflussen, wie QVariantAnimation die Werte interpoliert. Sie können eine Lockerungskurve festlegen, indem Sie setEasingCurve() aufrufen, und die Dauer konfigurieren, indem Sie setDuration() aufrufen. Sie können ändern, wie QVariantinterpoliert wird, indem Sie eine Unterklasse von QVariantAnimation erstellen und die virtuelle Funktion interpolated() neu implementieren.

Eine Unterklasse von QVariantAnimation kann eine Alternative sein, wenn Sie QVariants 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 Eigenschaft zu deklarieren.

Nicht alle QVariant Typen werden unterstützt. Im Folgenden finden Sie eine Liste der derzeit unterstützten QVariant Typen:

Wenn Sie andere Variantentypen, einschließlich benutzerdefinierter Typen, interpolieren möchten, müssen Sie die Interpolation für diese Typen selbst implementieren. Zu diesem Zweck können Sie eine Interpolatorfunktion für einen bestimmten Typ registrieren. Diese Funktion benötigt 3 Parameter: den Startwert, den Endwert und den aktuellen Fortschritt.

Beispiel:

    QVariant myColorInterpolator(const QColor &start, const QColor&end, qreal progress) { ... return QColor(...); } ...    qRegisterAnimationInterpolator<QColor>(myColorInterpolator);

Eine andere Möglichkeit ist die Neuimplementierung von interpolated(), die Interpolationswerte für den zu interpolierenden Wert zurückgibt.

Siehe auch QPropertyAnimation, QAbstractAnimation, und The Animation Framework.

Dokumentation der Mitgliedstypen

[alias] QVariantAnimation::KeyValue

Dies ist ein Typedef für std::pair<qreal, QVariant>.

QVariantAnimation::KeyValues

Dies ist ein Typendefinition für QList<KeyValue>

Dokumentation der Eigenschaft

[read-only] currentValue : const QVariant

Diese Eigenschaft enthält den aktuellen Wert der Animation.

Diese Eigenschaft beschreibt den aktuellen Wert; ein interpolierter Wert zwischen start value und end value, wobei die aktuelle Zeit für den Fortschritt verwendet wird. Der Wert selbst wird von interpolated() bezogen, die wiederholt aufgerufen wird, während die Animation läuft.

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. Zum Beispiel 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 QProperty Bindungen.

Diese Eigenschaft enthält die Dauer der Animation

Diese Eigenschaft beschreibt die Dauer der Animation in Millisekunden. Die Standarddauer beträgt 250 Millisekunden.

Siehe auch QAbstractAnimation::duration().

[bindable] easingCurve : QEasingCurve

Hinweis: Diese Eigenschaft unterstützt QProperty Bindungen.

Diese Eigenschaft enthält die Entspannungskurve der Animation

Diese Eigenschaft definiert die Lockerungskurve der Animation. Standardmäßig wird eine lineare Lockerungskurve verwendet, die zu einer linearen Interpolation führt. Es werden auch andere Kurven angeboten, z. B. QEasingCurve::InCirc, die eine kreisförmige Eingangskurve bietet. Ein weiteres Beispiel ist QEasingCurve::InOutElastic, das einen elastischen Effekt auf die Werte der interpolierten Variante bietet.

QVariantAnimation wird QEasingCurve::valueForProgress() verwenden, um den "normalisierten Fortschritt" (currentTime / totalDuration) der Animation in den effektiven Fortschritt umzuwandeln, der tatsächlich von der Animation verwendet wird. Es ist dieser effektive Fortschritt, der der Fortschritt ist, wenn interpolated() aufgerufen wird. Auch die Schritte in keyValues beziehen sich auf diesen effektiven Fortschritt.

Die Entspannungskurve 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.

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. Wenn sie weggelassen wird oder wenn als Startwert eine Null QVariant zugewiesen wird, verwendet die Animation die aktuelle Position des Endes, wenn die Animation gestartet wird.

Zugriffsfunktionen:

QVariant startValue() const
void setStartValue(const QVariant &value)

Siehe auch endValue.

Dokumentation der Mitgliedsfunktionen

QVariantAnimation::QVariantAnimation(QObject *parent = nullptr)

Konstruieren Sie ein QVariantAnimation-Objekt. parent wird an den Konstruktor von QAbstractAnimation übergeben.

[virtual noexcept] QVariantAnimation::~QVariantAnimation()

Zerstört die Animation.

[override virtual protected] bool QVariantAnimation::event(QEvent *event)

Reimplements: QAbstractAnimation::event(QEvent *Event).

[virtual protected] QVariant QVariantAnimation::interpolated(const QVariant &from, const QVariant &to, qreal progress) const

Diese virtuelle Funktion liefert die lineare Interpolation zwischen den Varianten from und to, bei progress, normalerweise einen Wert zwischen 0 und 1. Sie können diese Funktion in einer Unterklasse von QVariantAnimation neu implementieren, um Ihren eigenen Interpolationsalgorithmus bereitzustellen.

Damit die Interpolation mit einer QEasingCurve funktioniert, die einen Wert kleiner als 0 oder größer als 1 zurückgibt (wie QEasingCurve::InBack), sollten Sie sicherstellen, dass sie extrapolieren kann. Wenn die Semantik des Datentyps eine Extrapolation nicht zulässt, sollte diese Funktion dies elegant behandeln.

Sie sollten die QVariantAnimation -Implementierung dieser Funktion aufrufen, wenn Sie möchten, dass Ihre Klasse mit den bereits von Qt unterstützten Typen umgehen kann (siehe Beschreibung der Klasse QVariantAnimation für eine Liste der unterstützten Typen).

Siehe auch QEasingCurve.

QVariant QVariantAnimation::keyValueAt(qreal step) const

Gibt den Keyframe-Wert für den angegebenen step zurück. Der angegebene step muss im Bereich von 0 bis 1 liegen. Wenn es für step kein KeyValue gibt, wird ein ungültiger 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)

Erzeugt einen Keyframe am angegebenen step mit dem angegebenen value. Die angegebene step muss im Bereich von 0 bis 1 liegen.

Siehe auch setKeyValues() und keyValueAt().

void QVariantAnimation::setKeyValues(const QVariantAnimation::KeyValues &keyValues)

Ersetzt den aktuellen Satz von Schlüsselbildern durch den angegebenen keyValues. Der Schritt der Schlüsselbilder muss im Bereich von 0 bis 1 liegen.

Siehe auch keyValues() und keyValueAt().

[override virtual protected] void QVariantAnimation::updateCurrentTime(int)

Reimplements: 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 tut nichts.

Siehe auch currentValue.

[override virtual protected] void QVariantAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)

Reimplements: QAbstractAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState).

[signal] void QVariantAnimation::valueChanged(const QVariant &value)

QVariantAnimation gibt dieses Signal aus, wenn sich die aktuelle value ändert.

Hinweis: Benachrichtigungssignal für die Eigenschaft currentValue.

Siehe auch currentValue, startValue, und endValue.

Verwandte Nicht-Mitglieder

template <typename T> void qRegisterAnimationInterpolator(QVariant (*)(const T &, const T &, qreal) func)

Registriert einen benutzerdefinierten Interpolator func für den Vorlagentyp T. Der Interpolator muss registriert werden, bevor die Animation erstellt wird. Um die Registrierung aufzuheben (und den Standardinterpolator zu verwenden), setzen Sie func auf nullptr.

Hinweis: Diese Funktion ist thread-sicher.

© 2025 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.