io.qt.core.QInstanceMemberSignals Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of qtjambi Show documentation
Show all versions of qtjambi Show documentation
QtJambi base module containing QtCore, QtGui and QtWidgets.
/****************************************************************************
**
** Copyright (C) 2009-2022 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.QNoDefaultValueException;
import io.qt.QNoSuchSlotException;
import io.qt.QtSignalEmitterInterface;
import io.qt.QtUninvokable;
import io.qt.core.QMetaObject.AbstractPrivateSignal0;
import io.qt.core.QMetaObject.AbstractPrivateSignal1;
import io.qt.core.QMetaObject.AbstractPrivateSignal2;
import io.qt.core.QMetaObject.AbstractPrivateSignal3;
import io.qt.core.QMetaObject.AbstractPrivateSignal4;
import io.qt.core.QMetaObject.AbstractPrivateSignal5;
import io.qt.core.QMetaObject.AbstractPrivateSignal6;
import io.qt.core.QMetaObject.AbstractPrivateSignal7;
import io.qt.core.QMetaObject.AbstractPrivateSignal8;
import io.qt.core.QMetaObject.AbstractPrivateSignal9;
import io.qt.core.QMetaObject.AbstractPublicSignal0;
import io.qt.core.QMetaObject.AbstractPublicSignal1;
import io.qt.core.QMetaObject.AbstractPublicSignal2;
import io.qt.core.QMetaObject.AbstractPublicSignal3;
import io.qt.core.QMetaObject.AbstractPublicSignal4;
import io.qt.core.QMetaObject.AbstractPublicSignal5;
import io.qt.core.QMetaObject.AbstractPublicSignal6;
import io.qt.core.QMetaObject.AbstractPublicSignal7;
import io.qt.core.QMetaObject.AbstractPublicSignal8;
import io.qt.core.QMetaObject.AbstractPublicSignal9;
import io.qt.core.QMetaObject.AbstractSignal2Default1;
import io.qt.core.QMetaObject.AbstractSignal3Default1;
import io.qt.core.QMetaObject.AbstractSignal3Default2;
import io.qt.core.QMetaObject.AbstractSignal4Default1;
import io.qt.core.QMetaObject.AbstractSignal4Default2;
import io.qt.core.QMetaObject.AbstractSignal4Default3;
import io.qt.core.QMetaObject.AbstractSignal5Default1;
import io.qt.core.QMetaObject.AbstractSignal5Default2;
import io.qt.core.QMetaObject.AbstractSignal5Default3;
import io.qt.core.QMetaObject.AbstractSignal5Default4;
import io.qt.core.QMetaObject.AbstractSignal6Default1;
import io.qt.core.QMetaObject.AbstractSignal6Default2;
import io.qt.core.QMetaObject.AbstractSignal6Default3;
import io.qt.core.QMetaObject.AbstractSignal6Default4;
import io.qt.core.QMetaObject.AbstractSignal6Default5;
import io.qt.core.QMetaObject.AbstractSignal7Default1;
import io.qt.core.QMetaObject.AbstractSignal7Default2;
import io.qt.core.QMetaObject.AbstractSignal7Default3;
import io.qt.core.QMetaObject.AbstractSignal7Default4;
import io.qt.core.QMetaObject.AbstractSignal7Default5;
import io.qt.core.QMetaObject.AbstractSignal7Default6;
import io.qt.core.QMetaObject.AbstractSignal8Default1;
import io.qt.core.QMetaObject.AbstractSignal8Default2;
import io.qt.core.QMetaObject.AbstractSignal8Default3;
import io.qt.core.QMetaObject.AbstractSignal8Default4;
import io.qt.core.QMetaObject.AbstractSignal8Default5;
import io.qt.core.QMetaObject.AbstractSignal8Default6;
import io.qt.core.QMetaObject.AbstractSignal8Default7;
import io.qt.core.QMetaObject.AbstractSignal9Default1;
import io.qt.core.QMetaObject.AbstractSignal9Default2;
import io.qt.core.QMetaObject.AbstractSignal9Default3;
import io.qt.core.QMetaObject.AbstractSignal9Default4;
import io.qt.core.QMetaObject.AbstractSignal9Default5;
import io.qt.core.QMetaObject.AbstractSignal9Default6;
import io.qt.core.QMetaObject.AbstractSignal9Default7;
import io.qt.core.QMetaObject.AbstractSignal9Default8;
/**
* Interface giving access to non-QObject lightweight signals.
* Subtypes also need to implement {@link QtSignalEmitterInterface} to use signals.
*/
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(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public 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(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public 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(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public 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(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public 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(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public 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(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public 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(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public 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(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public 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(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public 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(Q containingObject) {
super();
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 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(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 QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal1Default1 extends AbstractPublicSignal1 implements QMetaObject.Emitable0, QMetaObject.Connectable0 {
@SuppressWarnings("unused")
private Signal1Default1(Q containingObject) {
this.arg1Default = null;
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(Q containingObject, Supplier arg1Default){
super();
if(arg1Default!=null){
this.arg1Default = arg1Default;
}else{
throw new QNoDefaultValueException(1);
}
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
private final Supplier arg1Default;
@Override public final void emit() {
emitDefaultSignal(arg1Default);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal2Default1 extends AbstractSignal2Default1{
@SuppressWarnings("unused")
private Signal2Default1(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(Q containingObject, Supplier arg2Default) {
super(arg2Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal2Default2 extends AbstractSignal2Default1 implements QMetaObject.Emitable0, QMetaObject.Connectable0 {
@SuppressWarnings("unused")
private Signal2Default2(Q containingObject) {
this.arg1Default = null;
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(Q containingObject, Supplier arg1Default, Supplier arg2Default){
super(arg2Default);
if(arg1Default!=null){
this.arg1Default = arg1Default;
}else{
throw new QNoDefaultValueException(1);
}
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
private final Supplier arg1Default;
@Override public final void emit() {
emitDefaultSignal(arg1Default);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal3Default1 extends AbstractSignal3Default1 {
@SuppressWarnings("unused")
private Signal3Default1(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(Q containingObject, Supplier arg3Default) {
super(arg3Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal3Default2 extends AbstractSignal3Default2 {
@SuppressWarnings("unused")
private Signal3Default2(Q containingObject) {
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
public Signal3Default2(Q containingObject, Supplier arg2Default, 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 QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal3Default3 extends AbstractSignal3Default2 implements QMetaObject.Emitable0, QMetaObject.Connectable0 {
@SuppressWarnings("unused")
private Signal3Default3(Q containingObject) {
this.arg1Default = null;
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(Q containingObject, Supplier arg1Default, Supplier arg2Default, Supplier arg3Default){
super(arg2Default, arg3Default);
if(arg2Default!=null){
this.arg1Default = arg1Default;
}else{
throw new QNoDefaultValueException(1);
}
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
private final Supplier arg1Default;
@Override public final void emit() {
emitDefaultSignal(arg1Default);
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal4Default1 extends AbstractSignal4Default1{
@SuppressWarnings("unused")
private Signal4Default1(Q containingObject) {
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
public Signal4Default1(Q containingObject, Supplier arg4Default){
super(arg4Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal4Default2 extends AbstractSignal4Default2{
@SuppressWarnings("unused")
private Signal4Default2(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 Signal4Default2(Q containingObject, Supplier arg3Default, Supplier arg4Default){
super(arg3Default, arg4Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal4Default3 extends AbstractSignal4Default3{
@SuppressWarnings("unused")
private Signal4Default3(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 Signal4Default3(Q containingObject, Supplier arg2Default, Supplier arg3Default, Supplier arg4Default){
super(arg2Default, arg3Default, arg4Default);
this.containingObject = new WeakReference<>(Objects.requireNonNull(containingObject));
}
/**
* Returns the object containing this signal.
* @return the signal containing object
*/
@Override
public QtSignalEmitterInterface containingObject() {
return containingObject.get();
}
private final WeakReference containingObject;
}
public static final class Signal4Default4