All Downloads are FREE. Search and download functionalities are using the official Maven repository.

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

Go to download

QtJambi base module containing QtCore, QtGui and QtWidgets.

There is a newer version: 6.8.0
Show newest version
package io.qt.core;

import io.qt.*;


/**
 * 
Marks a deadline in the future

 * 
Java wrapper for Qt class QDeadlineTimer

 */
public class QDeadlineTimer extends QtObject
    implements java.lang.Comparable,
            java.lang.Cloneable
{
    static {
        QtJambi_LibraryUtilities.initialize();
    }
    
    /**
     * 
Java wrapper for Qt enum QDeadlineTimer::ForeverConstant

     */
    public enum ForeverConstant implements QtEnumerator {
        /**
         * 
Representing QDeadlineTimer::ForeverConstant::Forever

         */
        Forever(0);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

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

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

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull ForeverConstant resolve(int value) {
            switch (value) {
            case 0: return Forever;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    
    /**
     * 
See QDeadlineTimer::QDeadlineTimer()

     */
    public QDeadlineTimer(){
        super((QPrivateConstructor)null);
        initialize_native(this);
    }
    
    private native static void initialize_native(QDeadlineTimer instance);
    
    /**
     * 
See QDeadlineTimer::QDeadlineTimer(QDeadlineTimer)

     */
    public QDeadlineTimer(io.qt.core.@NonNull QDeadlineTimer other){
        super((QPrivateConstructor)null);
        initialize_native(this, other);
    }
    
    private native static void initialize_native(QDeadlineTimer instance, io.qt.core.QDeadlineTimer other);
    
    /**
     * 
See QDeadlineTimer::QDeadlineTimer(QDeadlineTimer::ForeverConstant,Qt::TimerType)

     */
    public QDeadlineTimer(io.qt.core.QDeadlineTimer.@NonNull ForeverConstant arg__1, io.qt.core.Qt.@NonNull TimerType type_){
        super((QPrivateConstructor)null);
        initialize_native(this, arg__1, type_);
    }
    
    private native static void initialize_native(QDeadlineTimer instance, io.qt.core.QDeadlineTimer.ForeverConstant arg__1, io.qt.core.Qt.TimerType type_);
    
    /**
     * 
See QDeadlineTimer::QDeadlineTimer(Qt::TimerType)

     */
    public QDeadlineTimer(io.qt.core.Qt.@NonNull TimerType type_){
        super((QPrivateConstructor)null);
        initialize_native(this, type_);
    }
    
    private native static void initialize_native(QDeadlineTimer instance, io.qt.core.Qt.TimerType type_);
    
    /**
     * 
See QDeadlineTimer::QDeadlineTimer(qint64,Qt::TimerType)

     */
    public QDeadlineTimer(long msecs, io.qt.core.Qt.@NonNull TimerType type){
        super((QPrivateConstructor)null);
        initialize_native(this, msecs, type);
    }
    
    private native static void initialize_native(QDeadlineTimer instance, long msecs, io.qt.core.Qt.TimerType type);
    
    /**
     * 
See QDeadlineTimer::deadline()const

     */
    @QtUninvokable
    public final long deadline(){
        return deadline_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native long deadline_native_constfct(long __this__nativeId);
    
    /**
     * 
See QDeadlineTimer::deadlineNSecs()const

     */
    @QtUninvokable
    public final long deadlineNSecs(){
        return deadlineNSecs_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native long deadlineNSecs_native_constfct(long __this__nativeId);
    
    /**
     * 
See QDeadlineTimer::hasExpired()const

     */
    @QtUninvokable
    public final boolean hasExpired(){
        return hasExpired_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean hasExpired_native_constfct(long __this__nativeId);
    
    /**
     * 
See QDeadlineTimer::isForever()const

     */
    @QtUninvokable
    public final boolean isForever(){
        return isForever_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean isForever_native_constfct(long __this__nativeId);
    
    /**
     * 
See operator+(QDeadlineTimer,qint64)

     */
    @QtUninvokable
    public final io.qt.core.@NonNull QDeadlineTimer plus(long msecs){
        return plus_native_qint64(QtJambi_LibraryUtilities.internal.nativeId(this), msecs);
    }
    
    @QtUninvokable
    private native io.qt.core.QDeadlineTimer plus_native_qint64(long __this__nativeId, long msecs);
    
    /**
     * 
See QDeadlineTimer::operator+=(qint64)

     */
    @QtUninvokable
    public final @NonNull QDeadlineTimer addMSecs(long msecs){
        return addMSecs_native_qint64(QtJambi_LibraryUtilities.internal.nativeId(this), msecs);
    }
    
    @QtUninvokable
    private native QDeadlineTimer addMSecs_native_qint64(long __this__nativeId, long msecs);
    
    /**
     * 
See operator-(QDeadlineTimer,QDeadlineTimer)

     */
    @QtUninvokable
    public final long minus(io.qt.core.@NonNull QDeadlineTimer dt2){
        return minus_native_QDeadlineTimer(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(dt2));
    }
    
    @QtUninvokable
    private native long minus_native_QDeadlineTimer(long __this__nativeId, long dt2);
    
    /**
     * 
See operator-(QDeadlineTimer,qint64)

     */
    @QtUninvokable
    public final io.qt.core.@NonNull QDeadlineTimer minus(long msecs){
        return minus_native_qint64(QtJambi_LibraryUtilities.internal.nativeId(this), msecs);
    }
    
    @QtUninvokable
    private native io.qt.core.QDeadlineTimer minus_native_qint64(long __this__nativeId, long msecs);
    
    /**
     * 
See QDeadlineTimer::operator-=(qint64)

     */
    @QtUninvokable
    public final @NonNull QDeadlineTimer subtractMSecs(long msecs){
        return subtractMSecs_native_qint64(QtJambi_LibraryUtilities.internal.nativeId(this), msecs);
    }
    
    @QtUninvokable
    private native QDeadlineTimer subtractMSecs_native_qint64(long __this__nativeId, long msecs);
    
    /**
     * 
See operator<(QDeadlineTimer,QDeadlineTimer)

     */
    @QtUninvokable
    private final boolean operator_less(io.qt.core.@NonNull QDeadlineTimer d2){
        return operator_less_native_QDeadlineTimer(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(d2));
    }
    
    @QtUninvokable
    private native boolean operator_less_native_QDeadlineTimer(long __this__nativeId, long d2);
    
    /**
     * 
See QDeadlineTimer::operator=(QDeadlineTimer)

     */
    @QtUninvokable
    public final void assign(io.qt.core.@NonNull QDeadlineTimer other){
        assign_native_cref_QDeadlineTimer(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(other));
    }
    
    @QtUninvokable
    private native void assign_native_cref_QDeadlineTimer(long __this__nativeId, long other);
    
    /**
     * 
See operator==(QDeadlineTimer,QDeadlineTimer)

     */
    @QtUninvokable
    public final boolean equals(io.qt.core.@NonNull QDeadlineTimer d2){
        return equals_native_QDeadlineTimer(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(d2));
    }
    
    @QtUninvokable
    private native boolean equals_native_QDeadlineTimer(long __this__nativeId, long d2);
    
    /**
     * 
See QDeadlineTimer::remainingTime()const

     */
    @QtUninvokable
    public final long remainingTime(){
        return remainingTime_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native long remainingTime_native_constfct(long __this__nativeId);
    
    /**
     * 
See QDeadlineTimer::remainingTimeAsDuration()const

     */
    @QtUninvokable
    public final java.time.@NonNull Duration remainingTimeAsDuration(){
        return remainingTimeAsDuration_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native java.time.Duration remainingTimeAsDuration_native_constfct(long __this__nativeId);
    
    /**
     * 
See QDeadlineTimer::remainingTimeNSecs()const

     */
    @QtUninvokable
    public final long remainingTimeNSecs(){
        return remainingTimeNSecs_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native long remainingTimeNSecs_native_constfct(long __this__nativeId);
    
    /**
     * 
See QDeadlineTimer::setDeadline(qint64,Qt::TimerType)

     */
    @QtUninvokable
    public final void setDeadline(long msecs, io.qt.core.Qt.@NonNull TimerType timerType){
        setDeadline_native_qint64_Qt_TimerType(QtJambi_LibraryUtilities.internal.nativeId(this), msecs, timerType.value());
    }
    
    @QtUninvokable
    private native void setDeadline_native_qint64_Qt_TimerType(long __this__nativeId, long msecs, int timerType);
    
    /**
     * 
See QDeadlineTimer::setPreciseDeadline(qint64,qint64,Qt::TimerType)

     */
    @QtUninvokable
    public final void setPreciseDeadline(long secs, long nsecs, io.qt.core.Qt.@NonNull TimerType type){
        setPreciseDeadline_native_qint64_qint64_Qt_TimerType(QtJambi_LibraryUtilities.internal.nativeId(this), secs, nsecs, type.value());
    }
    
    @QtUninvokable
    private native void setPreciseDeadline_native_qint64_qint64_Qt_TimerType(long __this__nativeId, long secs, long nsecs, int type);
    
    /**
     * 
See QDeadlineTimer::setPreciseRemainingTime(qint64,qint64,Qt::TimerType)

     */
    @QtUninvokable
    public final void setPreciseRemainingTime(long secs, long nsecs, io.qt.core.Qt.@NonNull TimerType type){
        setPreciseRemainingTime_native_qint64_qint64_Qt_TimerType(QtJambi_LibraryUtilities.internal.nativeId(this), secs, nsecs, type.value());
    }
    
    @QtUninvokable
    private native void setPreciseRemainingTime_native_qint64_qint64_Qt_TimerType(long __this__nativeId, long secs, long nsecs, int type);
    
    /**
     * 
See QDeadlineTimer::setRemainingTime(qint64,Qt::TimerType)

     */
    @QtUninvokable
    public final void setRemainingTime(long msecs, io.qt.core.Qt.@NonNull TimerType type){
        setRemainingTime_native_qint64_Qt_TimerType(QtJambi_LibraryUtilities.internal.nativeId(this), msecs, type.value());
    }
    
    @QtUninvokable
    private native void setRemainingTime_native_qint64_Qt_TimerType(long __this__nativeId, long msecs, int type);
    
    /**
     * 
See QDeadlineTimer::setTimerType(Qt::TimerType)

     */
    @QtUninvokable
    public final void setTimerType(io.qt.core.Qt.@NonNull TimerType type){
        setTimerType_native_Qt_TimerType(QtJambi_LibraryUtilities.internal.nativeId(this), type.value());
    }
    
    @QtUninvokable
    private native void setTimerType_native_Qt_TimerType(long __this__nativeId, int type);
    
    /**
     * 
See QDeadlineTimer::swap(QDeadlineTimer&)

     */
    @QtUninvokable
    public final void swap(io.qt.core.@StrictNonNull QDeadlineTimer other){
        java.util.Objects.requireNonNull(other, "Argument 'other': null not expected.");
        swap_native_ref_QDeadlineTimer(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(other));
    }
    
    @QtUninvokable
    private native void swap_native_ref_QDeadlineTimer(long __this__nativeId, long other);
    
    /**
     * 
See QDeadlineTimer::timerType()const

     */
    @QtUninvokable
    public final io.qt.core.Qt.@NonNull TimerType timerType(){
        return io.qt.core.Qt.TimerType.resolve(timerType_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int timerType_native_constfct(long __this__nativeId);
    
    /**
     * 
See QDeadlineTimer::addNSecs(QDeadlineTimer,qint64)

     */
    public static io.qt.core.@NonNull QDeadlineTimer addNSecs(io.qt.core.@NonNull QDeadlineTimer dt, long nsecs){
        return addNSecs_native_QDeadlineTimer_qint64(QtJambi_LibraryUtilities.internal.checkedNativeId(dt), nsecs);
    }
    
    private native static io.qt.core.QDeadlineTimer addNSecs_native_QDeadlineTimer_qint64(long dt, long nsecs);
    
    /**
     * 
See QDeadlineTimer::current(Qt::TimerType)

     */
    public static io.qt.core.@NonNull QDeadlineTimer current(io.qt.core.Qt.@NonNull TimerType timerType){
        return current_native_Qt_TimerType(timerType.value());
    }
    
    private native static io.qt.core.QDeadlineTimer current_native_Qt_TimerType(int timerType);
    
    /**
     * 
See QDeadlineTimer::Forever

     */
    private static io.qt.core.QDeadlineTimer.@NonNull ForeverConstant Forever(){
        return io.qt.core.QDeadlineTimer.ForeverConstant.resolve(Forever_native());
    }
    
    private native static int Forever_native();
    
    /**
     * 
See QDeadlineTimer::Forever

     */
    public static final io.qt.core.QDeadlineTimer.@NonNull ForeverConstant Forever = Forever();

    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QDeadlineTimer(QPrivateConstructor p) { super(p); } 
    

    /**
     * 
See operator==(QDeadlineTimer,QDeadlineTimer)

     */
    @Override
    @QtUninvokable
    public boolean equals(Object other) {
        if (other==null || other instanceof io.qt.core.QDeadlineTimer) {
            return equals((io.qt.core.QDeadlineTimer) other);
        }

        return false;
    }

    /**
     * 
See operator<(QDeadlineTimer,QDeadlineTimer)

     */
    @QtUninvokable
    public int compareTo(io.qt.core.@StrictNonNull QDeadlineTimer other) {
        if (equals(other)) return 0;
        else if (operator_less(other)) return -1;
        else return 1;
    }


    /**
     * Returns the objects's hash code computed by qHash(QDeadlineTimer).
     */
    @QtUninvokable
    @Override
    public int hashCode() {
        return hashCode_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    @QtUninvokable
    private native static int hashCode_native(long __this_nativeId);
    /**
     * 
Overloaded constructor for {@link #QDeadlineTimer(java.time.temporal.TemporalAmount, io.qt.core.Qt.TimerType)}
     *  with type = io.qt.core.Qt.TimerType.CoarseTimer.

     */
    public QDeadlineTimer(java.time.temporal.@NonNull TemporalAmount remaining) {
        this(remaining, io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * 
See QDeadlineTimer::QDeadlineTimer(std::chrono::duration, Qt::TimerType)

     */
    public QDeadlineTimer(java.time.temporal.@NonNull TemporalAmount remaining, io.qt.core.Qt.@NonNull TimerType type){
        this(ForeverConstant.Forever, type);
        java.time.Duration duration;
        if(remaining instanceof java.time.Duration)
            duration = (java.time.Duration)remaining;
        else
            duration = java.time.Duration.from(remaining);
        if(duration.getSeconds()>=0 && duration.getSeconds()Overloaded constructor for {@link #QDeadlineTimer(java.time.temporal.Temporal, io.qt.core.Qt.TimerType)}
     *  with type = io.qt.core.Qt.TimerType.CoarseTimer.

     */
    public QDeadlineTimer(java.time.temporal.@NonNull Temporal timePoint) {
        this(timePoint, io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * 
See QDeadlineTimer::QDeadlineTimer(std::chrono::time_point, Qt::TimerType)

     */
    public QDeadlineTimer(java.time.temporal.@NonNull Temporal timePoint, io.qt.core.Qt.@NonNull TimerType type){
        this(ForeverConstant.Forever, type);
        java.time.Instant instant;
        if(timePoint instanceof java.time.Instant) {
            instant = (java.time.Instant)timePoint;
        }else {
            instant = java.time.Instant.from(timePoint);
        }
        if(!java.time.Instant.MAX.equals(instant)) {
            setPreciseDeadline(instant.getEpochSecond(), instant.getNano(), type);
        }
    }
    
    /**
     * 
Overloaded method for {@link #setRemainingTime(java.time.temporal.TemporalAmount, io.qt.core.Qt.TimerType)}
     *  with type = io.qt.core.Qt.TimerType.CoarseTimer.

     */
    public void setRemainingTime(java.time.temporal.@NonNull TemporalAmount remaining) {
        setRemainingTime(remaining, io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * 
See QDeadlineTimer::setRemainingTime(std::chrono::duration, Qt::TimerType)

     */
    public void setRemainingTime(java.time.temporal.@NonNull TemporalAmount remaining, io.qt.core.Qt.@NonNull TimerType type){
        java.time.Duration duration;
        if(remaining instanceof java.time.Duration)
            duration = (java.time.Duration)remaining;
        else
            duration = java.time.Duration.from(remaining);
        if(duration.getSeconds()>=0 && duration.getSeconds()Overloaded method for {@link #setDeadline(java.time.temporal.Temporal, io.qt.core.Qt.TimerType)}
     *  with type = io.qt.core.Qt.TimerType.CoarseTimer.

     */
    public void setDeadline(java.time.temporal.@NonNull Temporal timePoint) {
        setDeadline(timePoint, io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * 
See QDeadlineTimer::setDeadline(std::chrono::time_point, Qt::TimerType)

     */
    public void setDeadline(java.time.temporal.@NonNull Temporal timePoint, io.qt.core.Qt.@NonNull TimerType type){
        java.time.Instant instant;
        if(timePoint instanceof java.time.Instant) {
            instant = (java.time.Instant)timePoint;
        }else {
            instant = java.time.Instant.from(timePoint);
        }
        if(!java.time.Instant.MAX.equals(instant)) {
            setPreciseDeadline(instant.getEpochSecond(), instant.getNano(), type);
        }else {
            assign(new QDeadlineTimer(ForeverConstant.Forever));
        }
    }
    
    /**
     * 
See QDeadlineTimer::operator=(std::chrono::time_point)

     */
    @QtUninvokable
    public final void assign(java.time.temporal.@NonNull Temporal timePoint){
        setDeadline(timePoint);
    }
    
    /**
     * 
See QDeadlineTimer::operator=(std::chrono::duration)

     */
    @QtUninvokable
    public final void assign(java.time.temporal.@NonNull TemporalAmount remaining){
        setRemainingTime(remaining);
    }
    
    /**
     * 
See operator+(QDeadlineTimer,std::chrono::duration)

     */
    @QtUninvokable
    public final io.qt.core.@NonNull QDeadlineTimer plus(java.time.temporal.@NonNull TemporalAmount remaining){
        java.time.Duration duration;
        if(remaining instanceof java.time.Duration)
            duration = (java.time.Duration)remaining;
        else
            duration = java.time.Duration.from(remaining);
        return addNSecs(this, duration.toNanos());
    }
    
    /**
     * 
See QDeadlineTimer::deadline()const

     */
    @QtUninvokable
    public final  @NonNull T deadline(Class type){
        java.time.Instant instant = java.time.Instant.ofEpochSecond(0, deadlineNSecs());
        if(type.isInstance(instant)) {
            return type.cast(instant);
        }else if(type.isAssignableFrom(java.time.LocalDate.class)) {
            return type.cast(java.time.LocalDate.from(instant));
        }else if(type.isAssignableFrom(java.time.LocalDateTime.class)) {
            return type.cast(java.time.LocalDateTime.from(instant));
        }else if(type.isAssignableFrom(java.time.LocalTime.class)) {
            return type.cast(java.time.LocalTime.from(instant));
        }else if(type.isAssignableFrom(java.time.OffsetTime.class)) {
            return type.cast(java.time.OffsetTime.from(instant));
        }else if(type.isAssignableFrom(java.time.OffsetDateTime.class)) {
            return type.cast(java.time.OffsetDateTime.from(instant));
        }else if(type.isAssignableFrom(java.time.ZonedDateTime.class)) {
            return type.cast(java.time.ZonedDateTime.from(instant));
        }else {
            throw new IllegalArgumentException("Deadline cannot be expressed by type "+type.getName());
        }
    }
    
    /**
     * 
Creates and returns a copy of this object.

    
See QDeadlineTimer::QDeadlineTimer(QDeadlineTimer)

     */
    @QtUninvokable
    @Override
    public QDeadlineTimer clone() {
        return clone_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    private static native QDeadlineTimer clone_native(long __this_nativeId);
    
    /**
     * 
Overloaded constructor for {@link #QDeadlineTimer(io.qt.core.QDeadlineTimer.ForeverConstant, io.qt.core.Qt.TimerType)}
     *  with type_ = io.qt.core.Qt.TimerType.CoarseTimer.

     */
    public QDeadlineTimer(io.qt.core.QDeadlineTimer.@NonNull ForeverConstant arg__1) {
        this(arg__1, io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * 
Overloaded constructor for {@link #QDeadlineTimer(long, io.qt.core.Qt.TimerType)}
     *  with type = io.qt.core.Qt.TimerType.CoarseTimer.

     */
    public QDeadlineTimer(long msecs) {
        this(msecs, io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * 
Overloaded function for {@link #minus(io.qt.core.QDeadlineTimer)}.

     */
    @QtUninvokable
    public final long minus(io.qt.core.QDeadlineTimer.@NonNull ForeverConstant dt2) {
        return minus(new io.qt.core.QDeadlineTimer(dt2));
    }
    
    /**
     * 
Overloaded function for {@link #operator_less(io.qt.core.QDeadlineTimer)}.

     */
    @QtUninvokable
    private final boolean operator_less(io.qt.core.QDeadlineTimer.@NonNull ForeverConstant d2) {
        return operator_less(new io.qt.core.QDeadlineTimer(d2));
    }
    
    /**
     * 
Overloaded function for {@link #assign(io.qt.core.QDeadlineTimer)}.

     */
    @QtUninvokable
    public final void assign(io.qt.core.QDeadlineTimer.@NonNull ForeverConstant other) {
        assign(new io.qt.core.QDeadlineTimer(other));
    }
    
    /**
     * 
Overloaded function for {@link #equals(io.qt.core.QDeadlineTimer)}.

     */
    @QtUninvokable
    public final boolean equals(io.qt.core.QDeadlineTimer.@NonNull ForeverConstant d2) {
        return equals(new io.qt.core.QDeadlineTimer(d2));
    }
    
    /**
     * 
Overloaded function for {@link #setDeadline(long, io.qt.core.Qt.TimerType)}
     *  with timerType = io.qt.core.Qt.TimerType.CoarseTimer.

     */
    @QtUninvokable
    public final void setDeadline(long msecs) {
        setDeadline(msecs, io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * 
Overloaded function for {@link #setPreciseDeadline(long, long, io.qt.core.Qt.TimerType)}
     *  with type = io.qt.core.Qt.TimerType.CoarseTimer.

     */
    @QtUninvokable
    public final void setPreciseDeadline(long secs, long nsecs) {
        setPreciseDeadline(secs, nsecs, io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * 
Overloaded function for {@link #setPreciseDeadline(long, long, io.qt.core.Qt.TimerType)}

     * 
with: 
    
     * 
  • nsecs = 0
    • 
     * 
  • type = io.qt.core.Qt.TimerType.CoarseTimer
    • 
     * 

     */
    @QtUninvokable
    public final void setPreciseDeadline(long secs) {
        setPreciseDeadline(secs, (long)0, io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * 
Overloaded function for {@link #setPreciseRemainingTime(long, long, io.qt.core.Qt.TimerType)}
     *  with type = io.qt.core.Qt.TimerType.CoarseTimer.

     */
    @QtUninvokable
    public final void setPreciseRemainingTime(long secs, long nsecs) {
        setPreciseRemainingTime(secs, nsecs, io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * 
Overloaded function for {@link #setPreciseRemainingTime(long, long, io.qt.core.Qt.TimerType)}

     * 
with: 
    
     * 
  • nsecs = 0
    • 
     * 
  • type = io.qt.core.Qt.TimerType.CoarseTimer
    • 
     * 

     */
    @QtUninvokable
    public final void setPreciseRemainingTime(long secs) {
        setPreciseRemainingTime(secs, (long)0, io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * 
Overloaded function for {@link #setRemainingTime(long, io.qt.core.Qt.TimerType)}
     *  with type = io.qt.core.Qt.TimerType.CoarseTimer.

     */
    @QtUninvokable
    public final void setRemainingTime(long msecs) {
        setRemainingTime(msecs, io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * 
Overloaded function for {@link #addNSecs(io.qt.core.QDeadlineTimer, long)}.

     */
    public static io.qt.core.@NonNull QDeadlineTimer addNSecs(io.qt.core.QDeadlineTimer.@NonNull ForeverConstant dt, long nsecs) {
        return addNSecs(new io.qt.core.QDeadlineTimer(dt), nsecs);
    }
    
    /**
     * 
Overloaded function for {@link #current(io.qt.core.Qt.TimerType)}
     *  with timerType = io.qt.core.Qt.TimerType.CoarseTimer.

     */
    public static io.qt.core.@NonNull QDeadlineTimer current() {
        return current(io.qt.core.Qt.TimerType.CoarseTimer);
    }
    
    /**
     * @hidden
     * 
Kotlin property getter. In Java use {@link #Forever()} instead.

     */
    private static io.qt.core.QDeadlineTimer.@NonNull ForeverConstant getForever() {
        return Forever();
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy