io.qt.core.QInstanceMemberSignals Maven / Gradle / Ivy
/****************************************************************************
**
** Copyright (C) 2009-2024 Dr. Peter Droste, Omix Visualization GmbH & Co. KG. All rights reserved.
**
** This file is part of Qt Jambi.
**
** $BEGIN_LICENSE$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
** $END_LICENSE$
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/
package io.qt.core;
import java.lang.ref.WeakReference;
import java.util.Objects;
import java.util.function.Supplier;
import io.qt.*;
import io.qt.core.QMetaObject.*;
/**
* Interface giving access to non-QObject lightweight signals.
* Subtypes also need to implement {@link QtSignalEmitterInterface} to use signals.
* Non-QObject signals are never realized as Qt's meta object signals but have a lightweight Java implementation.
*/
public interface QInstanceMemberSignals {
/**
* Use this signal class to define a non-QObject signal.
*/
public static final class Signal0 extends AbstractPublicSignal0 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal0(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
*/
public static final class Signal1 extends AbstractPublicSignal1 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal1(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal2 extends AbstractPublicSignal2 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal2(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal3 extends AbstractPublicSignal3 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal3(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal4 extends AbstractPublicSignal4 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal4(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal5 extends AbstractPublicSignal5 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal5(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal6 extends AbstractPublicSignal6 {
public Signal6(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal7 extends AbstractPublicSignal7 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal7(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal8 extends AbstractPublicSignal8 {
public Signal8(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Use this signal class to define a non-QObject signal.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class Signal9 extends AbstractPublicSignal9 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal9(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*/
public static final class PrivateSignal0 extends AbstractPrivateSignal0 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal0(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit() {
emitSignal();
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal1 extends AbstractPrivateSignal1 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal1(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1) {
emitSignal(arg1);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal2 extends AbstractPrivateSignal2 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal2(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2) {
emitSignal(arg1, arg2);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal3 extends AbstractPrivateSignal3 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal3(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3) {
emitSignal(arg1, arg2, arg3);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal4 extends AbstractPrivateSignal4 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal4(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3, D arg4) {
emitSignal(arg1, arg2, arg3, arg4);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal5 extends AbstractPrivateSignal5 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal5(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3, D arg4, E arg5) {
emitSignal(arg1, arg2, arg3, arg4, arg5);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal6 extends AbstractPrivateSignal6 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal6(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3, D arg4, E arg5, F arg6) {
emitSignal(arg1, arg2, arg3, arg4, arg5, arg6);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal7 extends AbstractPrivateSignal7 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal7(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7) {
emitSignal(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal8 extends AbstractPrivateSignal8 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal8(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7, H arg8) {
emitSignal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Declare and instantiate a field of this class in your
* QtSignalEmitterInterface subclass to declare a signal that takes nine
* parameters.
*
* Private signals do not have an emit method, as they can only be
* emitted from inside the declaring class.
*
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
* @param The type of the single parameter of the signal.
*/
public static final class PrivateSignal9 extends AbstractPrivateSignal9 {
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public PrivateSignal9(@StrictNonNull Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
@QtUninvokable
private void emit(A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7, H arg8, I arg9) {
emitSignal(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal1Default1 extends AbstractSignal1Default1{
@SuppressWarnings("unused")
private Signal1Default1(@StrictNonNull Q containingObject) {
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal1Default1(@StrictNonNull Q containingObject, @StrictNonNull Supplier arg1Default){
super(arg1Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Equivalent to {@link Signal2} with default value for parameter no. 2.
*
* @param The type of the first parameter of the signal.
* @param The type of the second parameter of the signal.
*/
public static final class Signal2Default1 extends AbstractSignal2Default1{
@SuppressWarnings("unused")
private Signal2Default1(@StrictNonNull Q containingObject) {
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal2Default1(@StrictNonNull Q containingObject, @StrictNonNull Supplier arg2Default) {
super(arg2Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Equivalent to {@link Signal2} with default values for parameters 1 and 2.
*
* @param The type of the first parameter of the signal.
* @param The type of the second parameter of the signal.
*/
public static final class Signal2Default2 extends AbstractSignal2Default2{
@SuppressWarnings("unused")
private Signal2Default2(@StrictNonNull Q containingObject) {
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal2Default2(@StrictNonNull Q containingObject, @StrictNonNull Supplier arg1Default, @StrictNonNull Supplier arg2Default){
super(arg1Default, arg2Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Equivalent to {@link Signal3} with default value for parameter no. 3.
*
* @param The type of the first parameter of the signal.
* @param The type of the second parameter of the signal.
* @param The type of the third parameter of the signal.
*/
public static final class Signal3Default1 extends AbstractSignal3Default1 {
@SuppressWarnings("unused")
private Signal3Default1(@StrictNonNull Q containingObject) {
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal3Default1(@StrictNonNull Q containingObject, @StrictNonNull Supplier arg3Default) {
super(arg3Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Equivalent to {@link Signal3} with default values for parameters 2 and 3.
*
* @param The type of the first parameter of the signal.
* @param The type of the second parameter of the signal.
* @param The type of the third parameter of the signal.
*/
public static final class Signal3Default2 extends AbstractSignal3Default2 {
@SuppressWarnings("unused")
private Signal3Default2(@StrictNonNull Q containingObject) {
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
public Signal3Default2(@StrictNonNull Q containingObject, @StrictNonNull Supplier arg2Default, @StrictNonNull Supplier arg3Default){
super(arg2Default, arg3Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Equivalent to {@link Signal3} with default values for parameters 1 to 3.
*
* @param The type of the first parameter of the signal.
* @param The type of the second parameter of the signal.
* @param The type of the third parameter of the signal.
*/
public static final class Signal3Default3 extends AbstractSignal3Default3{
@SuppressWarnings("unused")
private Signal3Default3(@StrictNonNull Q containingObject) {
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Create signal within containing object.
* @param type of the containing object.
* @param containingObject the containing object
*/
public Signal3Default3(@StrictNonNull Q containingObject, @StrictNonNull Supplier arg1Default, @StrictNonNull Supplier arg2Default, @StrictNonNull Supplier arg3Default){
super(arg1Default, arg2Default, arg3Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Equivalent to {@link Signal4} with default value for parameter no. 4.
*
* @param The type of the first parameter of the signal.
* @param The type of the second parameter of the signal.
* @param The type of the third parameter of the signal.
* @param The type of the fourth parameter of the signal.
*/
public static final class Signal4Default1 extends AbstractSignal4Default1{
@SuppressWarnings("unused")
private Signal4Default1(@StrictNonNull Q containingObject) {
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
public Signal4Default1(@StrictNonNull Q containingObject, @StrictNonNull Supplier arg4Default){
super(arg4Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public @NonNull QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
/**
* Equivalent to {@link Signal4} with default values for parameters 3 and 4.
*
* @param The type of the first parameter of the signal.
* @param The type of the second parameter of the signal.
* @param