io.qt.core.QEasingCurve Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of qtjambi Show documentation
QtJambi base module containing QtCore, QtGui and QtWidgets.
There is a newer version: 6.8.0
package io.qt.core;

import io.qt.*;


/**
 * Easing curves for controlling animation
 * Java wrapper for Qt class QEasingCurve
 */
public class QEasingCurve extends QtObject
    implements java.lang.Cloneable
{
    static {
        QtJambi_LibraryUtilities.initialize();
    }
    
    /**
     * This variable stores the meta-object for the class.
     */
    public static final io.qt.core.@NonNull QMetaObject staticMetaObject = io.qt.core.QMetaObject.forType(QEasingCurve.class);
    
    /**
     * Java wrapper for Qt enum QEasingCurve::Type
     */
    public enum Type implements QtEnumerator {
        /**
         * Representing QEasingCurve::Linear
         */
        Linear(0),
        /**
         * Representing QEasingCurve::InQuad
         */
        InQuad(1),
        /**
         * Representing QEasingCurve::OutQuad
         */
        OutQuad(2),
        /**
         * Representing QEasingCurve::InOutQuad
         */
        InOutQuad(3),
        /**
         * Representing QEasingCurve::OutInQuad
         */
        OutInQuad(4),
        /**
         * Representing QEasingCurve::InCubic
         */
        InCubic(5),
        /**
         * Representing QEasingCurve::OutCubic
         */
        OutCubic(6),
        /**
         * Representing QEasingCurve::InOutCubic
         */
        InOutCubic(7),
        /**
         * Representing QEasingCurve::OutInCubic
         */
        OutInCubic(8),
        /**
         * Representing QEasingCurve::InQuart
         */
        InQuart(9),
        /**
         * Representing QEasingCurve::OutQuart
         */
        OutQuart(10),
        /**
         * Representing QEasingCurve::InOutQuart
         */
        InOutQuart(11),
        /**
         * Representing QEasingCurve::OutInQuart
         */
        OutInQuart(12),
        /**
         * Representing QEasingCurve::InQuint
         */
        InQuint(13),
        /**
         * Representing QEasingCurve::OutQuint
         */
        OutQuint(14),
        /**
         * Representing QEasingCurve::InOutQuint
         */
        InOutQuint(15),
        /**
         * Representing QEasingCurve::OutInQuint
         */
        OutInQuint(16),
        /**
         * Representing QEasingCurve::InSine
         */
        InSine(17),
        /**
         * Representing QEasingCurve::OutSine
         */
        OutSine(18),
        /**
         * Representing QEasingCurve::InOutSine
         */
        InOutSine(19),
        /**
         * Representing QEasingCurve::OutInSine
         */
        OutInSine(20),
        /**
         * Representing QEasingCurve::InExpo
         */
        InExpo(21),
        /**
         * Representing QEasingCurve::OutExpo
         */
        OutExpo(22),
        /**
         * Representing QEasingCurve::InOutExpo
         */
        InOutExpo(23),
        /**
         * Representing QEasingCurve::OutInExpo
         */
        OutInExpo(24),
        /**
         * Representing QEasingCurve::InCirc
         */
        InCirc(25),
        /**
         * Representing QEasingCurve::OutCirc
         */
        OutCirc(26),
        /**
         * Representing QEasingCurve::InOutCirc
         */
        InOutCirc(27),
        /**
         * Representing QEasingCurve::OutInCirc
         */
        OutInCirc(28),
        /**
         * Representing QEasingCurve::InElastic
         */
        InElastic(29),
        /**
         * Representing QEasingCurve::OutElastic
         */
        OutElastic(30),
        /**
         * Representing QEasingCurve::InOutElastic
         */
        InOutElastic(31),
        /**
         * Representing QEasingCurve::OutInElastic
         */
        OutInElastic(32),
        /**
         * Representing QEasingCurve::InBack
         */
        InBack(33),
        /**
         * Representing QEasingCurve::OutBack
         */
        OutBack(34),
        /**
         * Representing QEasingCurve::InOutBack
         */
        InOutBack(35),
        /**
         * Representing QEasingCurve::OutInBack
         */
        OutInBack(36),
        /**
         * Representing QEasingCurve::InBounce
         */
        InBounce(37),
        /**
         * Representing QEasingCurve::OutBounce
         */
        OutBounce(38),
        /**
         * Representing QEasingCurve::InOutBounce
         */
        InOutBounce(39),
        /**
         * Representing QEasingCurve::OutInBounce
         */
        OutInBounce(40),
        /**
         * Representing QEasingCurve::InCurve
         */
        InCurve(41),
        /**
         * Representing QEasingCurve::OutCurve
         */
        OutCurve(42),
        /**
         * Representing QEasingCurve::SineCurve
         */
        SineCurve(43),
        /**
         * Representing QEasingCurve::CosineCurve
         */
        CosineCurve(44),
        /**
         * Representing QEasingCurve::BezierSpline
         */
        BezierSpline(45),
        /**
         * Representing QEasingCurve::TCBSpline
         */
        TCBSpline(46),
        /**
         * Representing QEasingCurve::Custom
         */
        Custom(47),
        /**
         * Representing QEasingCurve::NCurveTypes
         */
        NCurveTypes(48);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private Type(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull Type resolve(int value) {
            switch (value) {
            case 0: return Linear;
            case 1: return InQuad;
            case 2: return OutQuad;
            case 3: return InOutQuad;
            case 4: return OutInQuad;
            case 5: return InCubic;
            case 6: return OutCubic;
            case 7: return InOutCubic;
            case 8: return OutInCubic;
            case 9: return InQuart;
            case 10: return OutQuart;
            case 11: return InOutQuart;
            case 12: return OutInQuart;
            case 13: return InQuint;
            case 14: return OutQuint;
            case 15: return InOutQuint;
            case 16: return OutInQuint;
            case 17: return InSine;
            case 18: return OutSine;
            case 19: return InOutSine;
            case 20: return OutInSine;
            case 21: return InExpo;
            case 22: return OutExpo;
            case 23: return InOutExpo;
            case 24: return OutInExpo;
            case 25: return InCirc;
            case 26: return OutCirc;
            case 27: return InOutCirc;
            case 28: return OutInCirc;
            case 29: return InElastic;
            case 30: return OutElastic;
            case 31: return InOutElastic;
            case 32: return OutInElastic;
            case 33: return InBack;
            case 34: return OutBack;
            case 35: return InOutBack;
            case 36: return OutInBack;
            case 37: return InBounce;
            case 38: return OutBounce;
            case 39: return InOutBounce;
            case 40: return OutInBounce;
            case 41: return InCurve;
            case 42: return OutCurve;
            case 43: return SineCurve;
            case 44: return CosineCurve;
            case 45: return BezierSpline;
            case 46: return TCBSpline;
            case 47: return Custom;
            case 48: return NCurveTypes;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    

    /**
     * Java wrapper for Qt callable QEasingCurve::EasingFunction
     */
    @FunctionalInterface
    public interface EasingFunction extends QtObjectInterface, java.util.function.DoubleUnaryOperator {

        /**
         * @hidden
         * Implementor class for interface {@link EasingFunction}
         */
        public static abstract class Impl extends QtObject implements EasingFunction{
            static {
                QtJambi_LibraryUtilities.initialize();
            }

            public Impl(){
                super((QPrivateConstructor)null);
                initialize_native(this);
            }

            protected Impl(QPrivateConstructor p){
                super(p);
            }

            private static native void initialize_native(EasingFunction instance);

            @NativeAccess
            private final static class ConcreteWrapper extends Impl {
                private ConcreteWrapper(QPrivateConstructor c){
                    super(c);
                }

                @Override
                public native double applyAsDouble(double progress);
            }

        }
    }

    
    /**
     * See QEasingCurve::QEasingCurve(QEasingCurve)
     */
    public QEasingCurve(io.qt.core.@NonNull QEasingCurve other){
        super((QPrivateConstructor)null);
        initialize_native(this, other);
    }
    
    private native static void initialize_native(QEasingCurve instance, io.qt.core.QEasingCurve other);
    
    /**
     * See QEasingCurve::QEasingCurve(QEasingCurve::Type)
     */
    public QEasingCurve(io.qt.core.QEasingCurve.@NonNull Type type){
        super((QPrivateConstructor)null);
        initialize_native(this, type);
    }
    
    private native static void initialize_native(QEasingCurve instance, io.qt.core.QEasingCurve.Type type);
    
    /**
     * See QEasingCurve::addCubicBezierSegment(QPointF,QPointF,QPointF)
     */
    @QtUninvokable
    public final void addCubicBezierSegment(io.qt.core.@NonNull QPointF c1, io.qt.core.@NonNull QPointF c2, io.qt.core.@NonNull QPointF endPoint){
        addCubicBezierSegment_native_cref_QPointF_cref_QPointF_cref_QPointF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(c1), QtJambi_LibraryUtilities.internal.checkedNativeId(c2), QtJambi_LibraryUtilities.internal.checkedNativeId(endPoint));
    }
    
    @QtUninvokable
    private native void addCubicBezierSegment_native_cref_QPointF_cref_QPointF_cref_QPointF(long __this__nativeId, long c1, long c2, long endPoint);
    
    /**
     * See QEasingCurve::addTCBSegment(QPointF,qreal,qreal,qreal)
     */
    @QtUninvokable
    public final void addTCBSegment(io.qt.core.@NonNull QPointF nextPoint, double t, double c, double b){
        addTCBSegment_native_cref_QPointF_qreal_qreal_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(nextPoint), t, c, b);
    }
    
    @QtUninvokable
    private native void addTCBSegment_native_cref_QPointF_qreal_qreal_qreal(long __this__nativeId, long nextPoint, double t, double c, double b);
    
    /**
     * See QEasingCurve::amplitude()const
     */
    @QtUninvokable
    public final double amplitude(){
        return amplitude_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native double amplitude_native_constfct(long __this__nativeId);
    
    /**
     * See QEasingCurve::customType()const
     */
    @QtUninvokable
    public final io.qt.core.QEasingCurve.@Nullable EasingFunction customType(){
        return customType_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QEasingCurve.EasingFunction customType_native_constfct(long __this__nativeId);
    
    /**
     * See operator<<(QDataStream&,QEasingCurve)
     */
    @QtUninvokable
    public void writeTo(io.qt.core.@StrictNonNull QDataStream arg__1){
        java.util.Objects.requireNonNull(arg__1, "Argument 'arg__1': null not expected.");
        writeTo_native_ref_QDataStream(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1));
    }
    
    @QtUninvokable
    private native void writeTo_native_ref_QDataStream(long __this__nativeId, long arg__1);
    
    /**
     * See QEasingCurve::operator=(QEasingCurve)
     */
    @QtUninvokable
    public final void assign(io.qt.core.@NonNull QEasingCurve other){
        assign_native_cref_QEasingCurve(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(other));
    }
    
    @QtUninvokable
    private native void assign_native_cref_QEasingCurve(long __this__nativeId, long other);
    
    /**
     * See QEasingCurve::operator==(QEasingCurve)const
     */
    @QtUninvokable
    public final boolean equals(io.qt.core.@NonNull QEasingCurve other){
        return equals_native_cref_QEasingCurve_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(other));
    }
    
    @QtUninvokable
    private native boolean equals_native_cref_QEasingCurve_constfct(long __this__nativeId, long other);
    
    /**
     * See operator>>(QDataStream&,QEasingCurve&)
     */
    @QtUninvokable
    public void readFrom(io.qt.core.@StrictNonNull QDataStream arg__1){
        java.util.Objects.requireNonNull(arg__1, "Argument 'arg__1': null not expected.");
        readFrom_native_ref_QDataStream(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(arg__1));
    }
    
    @QtUninvokable
    private native void readFrom_native_ref_QDataStream(long __this__nativeId, long arg__1);
    
    /**
     * See QEasingCurve::overshoot()const
     */
    @QtUninvokable
    public final double overshoot(){
        return overshoot_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native double overshoot_native_constfct(long __this__nativeId);
    
    /**
     * See QEasingCurve::period()const
     */
    @QtUninvokable
    public final double period(){
        return period_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native double period_native_constfct(long __this__nativeId);
    
    /**
     * See QEasingCurve::setAmplitude(qreal)
     */
    @QtUninvokable
    public final void setAmplitude(double amplitude){
        setAmplitude_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), amplitude);
    }
    
    @QtUninvokable
    private native void setAmplitude_native_qreal(long __this__nativeId, double amplitude);
    
    /**
     * See QEasingCurve::setCustomType(QEasingCurve::EasingFunction)
     */
    @QtUninvokable
    public final void setCustomType(io.qt.core.QEasingCurve.@Nullable EasingFunction func){
        setCustomType_native_QEasingCurve_EasingFunction(QtJambi_LibraryUtilities.internal.nativeId(this), func);
    }
    
    @QtUninvokable
    private native void setCustomType_native_QEasingCurve_EasingFunction(long __this__nativeId, io.qt.core.QEasingCurve.EasingFunction func);
    
    /**
     * See QEasingCurve::setOvershoot(qreal)
     */
    @QtUninvokable
    public final void setOvershoot(double overshoot){
        setOvershoot_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), overshoot);
    }
    
    @QtUninvokable
    private native void setOvershoot_native_qreal(long __this__nativeId, double overshoot);
    
    /**
     * See QEasingCurve::setPeriod(qreal)
     */
    @QtUninvokable
    public final void setPeriod(double period){
        setPeriod_native_qreal(QtJambi_LibraryUtilities.internal.nativeId(this), period);
    }
    
    @QtUninvokable
    private native void setPeriod_native_qreal(long __this__nativeId, double period);
    
    /**
     * See QEasingCurve::setType(QEasingCurve::Type)
     */
    @QtUninvokable
    public final void setType(io.qt.core.QEasingCurve.@NonNull Type type){
        setType_native_QEasingCurve_Type(QtJambi_LibraryUtilities.internal.nativeId(this), type.value());
    }
    
    @QtUninvokable
    private native void setType_native_QEasingCurve_Type(long __this__nativeId, int type);
    
    /**
     * See QEasingCurve::swap(QEasingCurve&)
     */
    @QtUninvokable
    public final void swap(io.qt.core.@StrictNonNull QEasingCurve other){
        java.util.Objects.requireNonNull(other, "Argument 'other': null not expected.");
        swap_native_ref_QEasingCurve(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(other));
    }
    
    @QtUninvokable
    private native void swap_native_ref_QEasingCurve(long __this__nativeId, long other);
    
    /**
     * See QEasingCurve::toCubicSpline()const
     */
    @QtUninvokable
    public final io.qt.core.@NonNull QList toCubicSpline(){
        return toCubicSpline_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QList toCubicSpline_native_constfct(long __this__nativeId);
    
    /**
     * See QEasingCurve::type()const
     */
    @QtUninvokable
    public final io.qt.core.QEasingCurve.@NonNull Type type(){
        return io.qt.core.QEasingCurve.Type.resolve(type_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int type_native_constfct(long __this__nativeId);
    
    /**
     * See QEasingCurve::valueForProgress(qreal)const
     */
    @QtUninvokable
    public final double valueForProgress(double progress){
        return valueForProgress_native_qreal_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), progress);
    }
    
    @QtUninvokable
    private native double valueForProgress_native_qreal_constfct(long __this__nativeId, double progress);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QEasingCurve(QPrivateConstructor p) { super(p); } 
    

    /**
     * See QEasingCurve::operator==(QEasingCurve)const
     */
    @Override
    @QtUninvokable
    public boolean equals(Object other) {
        if (other instanceof io.qt.core.QEasingCurve) {
            return equals((io.qt.core.QEasingCurve) other);
        }

        return false;
    }


    /**
     * Returns the objects's hash code computed by qHash(QEasingCurve).
     */
    @QtUninvokable
    @Override
    public int hashCode() {
        return hashCode_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    @QtUninvokable
    private native static int hashCode_native(long __this_nativeId);

    /**
     * See operator<<(QDebug,QEasingCurve)
     */
    @QtUninvokable
    @Override
    public @NonNull String toString() {
        return toString_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    @QtUninvokable
    private static native String toString_native(long __this_nativeId);
    
    /**
     * Creates and returns a copy of this object.
    See QEasingCurve::QEasingCurve(QEasingCurve)
     */
    @QtUninvokable
    @Override
    public QEasingCurve clone() {
        return clone_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    private static native QEasingCurve clone_native(long __this_nativeId);
    
    /**
     * Overloaded constructor for {@link #QEasingCurve(io.qt.core.QEasingCurve.Type)}
     *  with type = io.qt.core.QEasingCurve.Type.Linear.
     */
    public QEasingCurve() {
        this(io.qt.core.QEasingCurve.Type.Linear);
    }
    
    /**
     * Overloaded function for {@link #addCubicBezierSegment(io.qt.core.QPointF, io.qt.core.QPointF, io.qt.core.QPointF)}.
     */
    @QtUninvokable
    public final void addCubicBezierSegment(io.qt.core.@NonNull QPoint c1, io.qt.core.@NonNull QPointF c2, io.qt.core.@NonNull QPointF endPoint) {
        addCubicBezierSegment(new io.qt.core.QPointF(c1), c2, endPoint);
    }
    
    /**
     * Overloaded function for {@link #addCubicBezierSegment(io.qt.core.QPointF, io.qt.core.QPointF, io.qt.core.QPointF)}.
     */
    @QtUninvokable
    public final void addCubicBezierSegment(io.qt.core.@NonNull QPointF c1, io.qt.core.@NonNull QPoint c2, io.qt.core.@NonNull QPointF endPoint) {
        addCubicBezierSegment(c1, new io.qt.core.QPointF(c2), endPoint);
    }
    
    /**
     * Overloaded function for {@link #addCubicBezierSegment(io.qt.core.QPointF, io.qt.core.QPointF, io.qt.core.QPointF)}.
     */
    @QtUninvokable
    public final void addCubicBezierSegment(io.qt.core.@NonNull QPoint c1, io.qt.core.@NonNull QPoint c2, io.qt.core.@NonNull QPointF endPoint) {
        addCubicBezierSegment(new io.qt.core.QPointF(c1), new io.qt.core.QPointF(c2), endPoint);
    }
    
    /**
     * Overloaded function for {@link #addCubicBezierSegment(io.qt.core.QPointF, io.qt.core.QPointF, io.qt.core.QPointF)}.
     */
    @QtUninvokable
    public final void addCubicBezierSegment(io.qt.core.@NonNull QPointF c1, io.qt.core.@NonNull QPointF c2, io.qt.core.@NonNull QPoint endPoint) {
        addCubicBezierSegment(c1, c2, new io.qt.core.QPointF(endPoint));
    }
    
    /**
     * Overloaded function for {@link #addCubicBezierSegment(io.qt.core.QPointF, io.qt.core.QPointF, io.qt.core.QPointF)}.
     */
    @QtUninvokable
    public final void addCubicBezierSegment(io.qt.core.@NonNull QPoint c1, io.qt.core.@NonNull QPointF c2, io.qt.core.@NonNull QPoint endPoint) {
        addCubicBezierSegment(new io.qt.core.QPointF(c1), c2, new io.qt.core.QPointF(endPoint));
    }
    
    /**
     * Overloaded function for {@link #addCubicBezierSegment(io.qt.core.QPointF, io.qt.core.QPointF, io.qt.core.QPointF)}.
     */
    @QtUninvokable
    public final void addCubicBezierSegment(io.qt.core.@NonNull QPointF c1, io.qt.core.@NonNull QPoint c2, io.qt.core.@NonNull QPoint endPoint) {
        addCubicBezierSegment(c1, new io.qt.core.QPointF(c2), new io.qt.core.QPointF(endPoint));
    }
    
    /**
     * Overloaded function for {@link #addCubicBezierSegment(io.qt.core.QPointF, io.qt.core.QPointF, io.qt.core.QPointF)}.
     */
    @QtUninvokable
    public final void addCubicBezierSegment(io.qt.core.@NonNull QPoint c1, io.qt.core.@NonNull QPoint c2, io.qt.core.@NonNull QPoint endPoint) {
        addCubicBezierSegment(new io.qt.core.QPointF(c1), new io.qt.core.QPointF(c2), new io.qt.core.QPointF(endPoint));
    }
    
    /**
     * Overloaded function for {@link #addTCBSegment(io.qt.core.QPointF, double, double, double)}.
     */
    @QtUninvokable
    public final void addTCBSegment(io.qt.core.@NonNull QPoint nextPoint, double t, double c, double b) {
        addTCBSegment(new io.qt.core.QPointF(nextPoint), t, c, b);
    }
    
    /**
     * Overloaded function for {@link #assign(io.qt.core.QEasingCurve)}.
     */
    @QtUninvokable
    public final void assign(io.qt.core.QEasingCurve.@NonNull Type other) {
        assign(new io.qt.core.QEasingCurve(other));
    }
    
    /**
     * Overloaded function for {@link #equals(io.qt.core.QEasingCurve)}.
     */
    @QtUninvokable
    public final boolean equals(io.qt.core.QEasingCurve.@NonNull Type other) {
        return equals(new io.qt.core.QEasingCurve(other));
    }
}