io.qt.gui.QPointingDevice 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.gui;

import io.qt.*;


/**
 * Describes a device from which mouse, touch or tablet events originate
 * Java wrapper for Qt class QPointingDevice
 */
public class QPointingDevice extends io.qt.gui.QInputDevice
{
    /**
     * This variable stores the meta-object for the class.
     */
    public static final io.qt.core.@NonNull QMetaObject staticMetaObject = io.qt.core.QMetaObject.forType(QPointingDevice.class);
    
    /**
     * Java wrapper for Qt enum QPointingDevice::GrabTransition
     */
    public enum GrabTransition implements QtEnumerator {
        /**
         * Representing QPointingDevice::GrabPassive
         */
        GrabPassive(1),
        /**
         * Representing QPointingDevice::UngrabPassive
         */
        UngrabPassive(2),
        /**
         * Representing QPointingDevice::CancelGrabPassive
         */
        CancelGrabPassive(3),
        /**
         * Representing QPointingDevice::OverrideGrabPassive
         */
        OverrideGrabPassive(4),
        /**
         * Representing QPointingDevice::GrabExclusive
         */
        GrabExclusive(16),
        /**
         * Representing QPointingDevice::UngrabExclusive
         */
        UngrabExclusive(32),
        /**
         * Representing QPointingDevice::CancelGrabExclusive
         */
        CancelGrabExclusive(48);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private GrabTransition(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 GrabTransition resolve(int value) {
            switch (value) {
            case 1: return GrabPassive;
            case 2: return UngrabPassive;
            case 3: return CancelGrabPassive;
            case 4: return OverrideGrabPassive;
            case 16: return GrabExclusive;
            case 32: return UngrabExclusive;
            case 48: return CancelGrabExclusive;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QPointingDevice::PointerType
     * 
     * @see PointerTypes
     */
    public enum PointerType implements QtFlagEnumerator {
        /**
         * Representing QPointingDevice::PointerType::Unknown
         */
        Unknown(0),
        /**
         * Representing QPointingDevice::PointerType::Generic
         */
        Generic(1),
        /**
         * Representing QPointingDevice::PointerType::Finger
         */
        Finger(2),
        /**
         * Representing QPointingDevice::PointerType::Pen
         */
        Pen(4),
        /**
         * Representing QPointingDevice::PointerType::Eraser
         */
        Eraser(8),
        /**
         * Representing QPointingDevice::PointerType::Cursor
         */
        Cursor(16),
        /**
         * Representing QPointingDevice::PointerType::AllPointerTypes
         */
        AllPointerTypes(32767);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

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

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

        /**
         * Create a QFlags of the enum entry.
         * @return QFlags
         */
        public @NonNull PointerTypes asFlags() {
            return new PointerTypes(value);
        }

        /**
         * Combines this entry with other enum entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull PointerTypes combined(@NonNull PointerType e) {
            return asFlags().setFlag(e, true);
        }

        /**
         * Excludes other enum entry from a flag of this entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull PointerTypes cleared(@NonNull PointerType e) {
            return asFlags().setFlag(e, false);
        }

        /**
         * Creates a new {@link PointerTypes} from the entries.
         * @param values entries
         * @return new flag
         */
        public static @NonNull PointerTypes flags(@Nullable PointerType @NonNull... values) {
            return new PointerTypes(values);
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull PointerType resolve(int value) {
            switch (value) {
            case 0: return Unknown;
            case 1: return Generic;
            case 2: return Finger;
            case 4: return Pen;
            case 8: return Eraser;
            case 16: return Cursor;
            case 32767: return AllPointerTypes;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * {@link QFlags} type for enum {@link PointerType}
     */
    public static final class PointerTypes extends QFlags implements Comparable {
        private static final long serialVersionUID = 0xa9b29eb9ef71f87cL;
        static {
            QtJambi_LibraryUtilities.initialize();
        }

        /**
         * Creates a new PointerTypes where the flags in args are set.
         * @param args enum entries
         */
        public PointerTypes(@Nullable PointerType @NonNull... args){
            super(args);
        }

        /**
         * Creates a new PointerTypes with given value.
         * @param value
         */
        public PointerTypes(int value) {
            super(value);
        }

        /**
         * Combines this flags with enum entry.
         * @param e enum entry
         * @return new PointerTypes
         */
        @Override
        public final @NonNull PointerTypes combined(@StrictNonNull PointerType e){
            return new PointerTypes(value() | e.value());
        }

        /**
         * Sets the flag e
         * @param e enum entry
         * @return this
         */
        public final @NonNull PointerTypes setFlag(@Nullable PointerType e){
            return setFlag(e, true);
        }

        /**
         * Sets or clears the flag flag
         * @param e enum entry
         * @param on set (true) or clear (false)
         * @return this
         */
        public final @NonNull PointerTypes setFlag(@Nullable PointerType e, boolean on){
            if (on) {
            	setValue(value() | e.value());
            }else {
            	setValue(value() & ~e.value());
            }
            return this;
        }

        /**
         * Returns an array of flag objects represented by this PointerTypes.
         * @return array of enum entries
         */
        @Override
        public final @NonNull PointerType @NonNull[] flags(){
            return super.flags(PointerType.values());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final @NonNull PointerTypes clone(){
            return new PointerTypes(value());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final int compareTo(@StrictNonNull PointerTypes other){
            return Integer.compare(value(), other.value());
        }
    }
    

    /**
     * See QPointingDevice::grabChanged(QObject*,QPointingDevice::GrabTransition,const QPointerEvent*,QEventPoint)const
     */
    public final @NonNull Signal4 grabChanged = new Signal4<>();
    
    /**
     * See QPointingDevice::QPointingDevice(QObject*)
     */
    public QPointingDevice(io.qt.core.@Nullable QObject parent){
        super((QPrivateConstructor)null);
        initialize_native(this, parent);
    }
    
    private native static void initialize_native(QPointingDevice instance, io.qt.core.QObject parent);
    
    /**
     * See QPointingDevice::QPointingDevice(QString,qint64,QInputDevice::DeviceType,QPointingDevice::PointerType,QInputDevice::Capabilities,int,int,QString,QPointingDeviceUniqueId,QObject*)
     */
    public QPointingDevice(java.lang.@NonNull String name, long systemId, io.qt.gui.QInputDevice.@NonNull DeviceType devType, io.qt.gui.QPointingDevice.@NonNull PointerType pType, io.qt.gui.QInputDevice.@NonNull Capabilities caps, int maxPoints, int buttonCount, java.lang.@NonNull String seatName, io.qt.gui.@NonNull QPointingDeviceUniqueId uniqueId, io.qt.core.@Nullable QObject parent){
        super((QPrivateConstructor)null);
        initialize_native(this, name, systemId, devType, pType, caps, maxPoints, buttonCount, seatName, uniqueId, parent);
    }
    
    private native static void initialize_native(QPointingDevice instance, java.lang.String name, long systemId, io.qt.gui.QInputDevice.DeviceType devType, io.qt.gui.QPointingDevice.PointerType pType, io.qt.gui.QInputDevice.Capabilities caps, int maxPoints, int buttonCount, java.lang.String seatName, io.qt.gui.QPointingDeviceUniqueId uniqueId, io.qt.core.QObject parent);
    
    /**
     * See QPointingDevice::buttonCount()const
     */
    @QtPropertyReader(name="buttonCount")
    @QtPropertyConstant
    @QtUninvokable
    public final int buttonCount(){
        return buttonCount_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int buttonCount_native_constfct(long __this__nativeId);
    
    /**
     * See QPointingDevice::maximumPoints()const
     */
    @QtPropertyReader(name="maximumPoints")
    @QtPropertyConstant
    @QtUninvokable
    public final int maximumPoints(){
        return maximumPoints_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int maximumPoints_native_constfct(long __this__nativeId);
    
    /**
     * See QPointingDevice::operator==(QPointingDevice)const
     */
    @QtUninvokable
    public final boolean equals(io.qt.gui.@StrictNonNull QPointingDevice other){
        java.util.Objects.requireNonNull(other, "Argument 'other': null not expected.");
        return equals_native_cref_QPointingDevice_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(other));
    }
    
    @QtUninvokable
    private native boolean equals_native_cref_QPointingDevice_constfct(long __this__nativeId, long other);
    
    /**
     * See QPointingDevice::pointerType()const
     */
    @QtPropertyReader(name="pointerType")
    @QtPropertyConstant
    @QtUninvokable
    public final io.qt.gui.QPointingDevice.@NonNull PointerType pointerType(){
        return io.qt.gui.QPointingDevice.PointerType.resolve(pointerType_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int pointerType_native_constfct(long __this__nativeId);
    
    /**
     * See QPointingDevice::uniqueId()const
     */
    @QtPropertyReader(name="uniqueId")
    @QtPropertyConstant
    @QtUninvokable
    public final io.qt.gui.@NonNull QPointingDeviceUniqueId uniqueId(){
        return uniqueId_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.gui.QPointingDeviceUniqueId uniqueId_native_constfct(long __this__nativeId);
    
    /**
     * See QPointingDevice::primaryPointingDevice(QString)
     */
    public native static io.qt.gui.@Nullable QPointingDevice primaryPointingDevice(java.lang.@NonNull String seatName);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QPointingDevice(QPrivateConstructor p) { super(p); } 
    
    /**
     * Constructor for internal use only.
     * It is not allowed to call the declarative constructor from inside Java.
     * @hidden
     */
    @NativeAccess
    protected QPointingDevice(QDeclarativeConstructor constructor) {
        super((QPrivateConstructor)null);
        initialize_native(this, constructor);
    } 
    
    @QtUninvokable
    private static native void initialize_native(QPointingDevice instance, QDeclarativeConstructor constructor);
    

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

        return false;
    }


    /**
     * See operator<<(QDebug,const QPointingDevice*)
     */
    @QtUninvokable
    @Override
    public @NonNull String toString() {
        return toString_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    @QtUninvokable
    private static native String toString_native(long __this_nativeId);
    
    /**
     * Overloaded constructor for {@link #QPointingDevice(io.qt.core.QObject)}
     *  with parent = null.
     */
    public QPointingDevice() {
        this((io.qt.core.QObject)null);
    }
    
    /**
     * Overloaded constructor for {@link #QPointingDevice(java.lang.String, long, io.qt.gui.QInputDevice.DeviceType, io.qt.gui.QPointingDevice.PointerType, io.qt.gui.QInputDevice.Capabilities, int, int, java.lang.String, io.qt.gui.QPointingDeviceUniqueId, io.qt.core.QObject)}
     *  with parent = null.
     */
    public QPointingDevice(java.lang.@NonNull String name, long systemId, io.qt.gui.QInputDevice.@NonNull DeviceType devType, io.qt.gui.QPointingDevice.@NonNull PointerType pType, io.qt.gui.QInputDevice.@NonNull Capabilities caps, int maxPoints, int buttonCount, java.lang.@NonNull String seatName, io.qt.gui.@NonNull QPointingDeviceUniqueId uniqueId) {
        this(name, systemId, devType, pType, caps, maxPoints, buttonCount, seatName, uniqueId, (io.qt.core.QObject)null);
    }
    
    /**
     * Overloaded constructor for {@link #QPointingDevice(java.lang.String, long, io.qt.gui.QInputDevice.DeviceType, io.qt.gui.QPointingDevice.PointerType, io.qt.gui.QInputDevice.Capabilities, int, int, java.lang.String, io.qt.gui.QPointingDeviceUniqueId, io.qt.core.QObject)}
     * with: 

     * uniqueId = new io.qt.gui.QPointingDeviceUniqueId()
     * parent = null
     * 
     */
    public QPointingDevice(java.lang.@NonNull String name, long systemId, io.qt.gui.QInputDevice.@NonNull DeviceType devType, io.qt.gui.QPointingDevice.@NonNull PointerType pType, io.qt.gui.QInputDevice.@NonNull Capabilities caps, int maxPoints, int buttonCount, java.lang.@NonNull String seatName) {
        this(name, systemId, devType, pType, caps, maxPoints, buttonCount, seatName, new io.qt.gui.QPointingDeviceUniqueId(), (io.qt.core.QObject)null);
    }
    
    /**
     * Overloaded constructor for {@link #QPointingDevice(java.lang.String, long, io.qt.gui.QInputDevice.DeviceType, io.qt.gui.QPointingDevice.PointerType, io.qt.gui.QInputDevice.Capabilities, int, int, java.lang.String, io.qt.gui.QPointingDeviceUniqueId, io.qt.core.QObject)}
     * with: 

     * seatName = (String)null
     * uniqueId = new io.qt.gui.QPointingDeviceUniqueId()
     * parent = null
     * 
     */
    public QPointingDevice(java.lang.@NonNull String name, long systemId, io.qt.gui.QInputDevice.@NonNull DeviceType devType, io.qt.gui.QPointingDevice.@NonNull PointerType pType, io.qt.gui.QInputDevice.@NonNull Capabilities caps, int maxPoints, int buttonCount) {
        this(name, systemId, devType, pType, caps, maxPoints, buttonCount, (String)null, new io.qt.gui.QPointingDeviceUniqueId(), (io.qt.core.QObject)null);
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #buttonCount()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final int getButtonCount() {
        return buttonCount();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #maximumPoints()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final int getMaximumPoints() {
        return maximumPoints();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #pointerType()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.gui.QPointingDevice.@NonNull PointerType getPointerType() {
        return pointerType();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #uniqueId()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.gui.@NonNull QPointingDeviceUniqueId getUniqueId() {
        return uniqueId();
    }
    
    /**
     * Overloaded function for {@link #primaryPointingDevice(java.lang.String)}
     *  with seatName = (String)null.
     */
    public static io.qt.gui.@Nullable QPointingDevice primaryPointingDevice() {
        return primaryPointingDevice((String)null);
    }
}