QObject Class

Documentación de las funciones miembro

[explicit invokable] QObject::QObject(QObject *parent = nullptr)

Construye un objeto con el objeto padre parent.

El padre de un objeto puede considerarse como su propietario. Por ejemplo, un dialog box es el padre de los botones OK y Cancel que contiene.

El destructor de un objeto padre destruye todos los objetos hijos.

Establecer parent a nullptr construye un objeto sin padre. Si el objeto es un widget, se convertirá en una ventana de nivel superior.

Véase también parent(), findChild(), y findChildren().

[virtual noexcept] QObject::~QObject()

Destruye el objeto, eliminando todos sus objetos hijos.

Todas las señales hacia y desde el objeto se desconectan automáticamente, y cualquier evento publicado pendiente para el objeto se elimina de la cola de eventos. Sin embargo, a menudo es más seguro utilizar deleteLater() en lugar de borrar directamente una subclase de QObject.

Véase también deleteLater().

[noexcept] bool QObject::blockSignals(bool block)

Si block es verdadero, las señales emitidas por este objeto se bloquean (es decir, emitir una señal no invocará nada conectado a ella). Si block es falso, no se producirá tal bloqueo.

El valor de retorno es el valor anterior de signalsBlocked().

Tenga en cuenta que la señal destroyed() se emitirá incluso si las señales de este objeto han sido bloqueadas.

Las señales emitidas mientras están bloqueadas no se almacenan en el buffer.

Véase también signalsBlocked() y QSignalBlocker.

[virtual protected] void QObject::childEvent(QChildEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos hijos. El evento se pasa en el parámetro event.

QEvent::ChildAdded y QEvent::ChildRemoved se envían a los objetos cuando se añaden o eliminan hijos. En ambos casos sólo se puede confiar en que el hijo sea un QObject, o si isWidgetType() devuelve true, un QWidget. (Esto se debe a que, en el caso ChildAdded, el hijo aún no está completamente construido, y en el caso ChildRemoved puede que ya haya sido destruido).

QEvent::ChildPolished Se envían eventos a los widgets cuando se pulen los hijos, o cuando se añaden hijos pulidos. Si recibes un evento de hijo pulido, la construcción del hijo normalmente se ha completado. Sin embargo, esto no está garantizado, y pueden enviarse múltiples eventos de pulido durante la ejecución del constructor de un widget.

Por cada widget hijo se recibe un evento ChildAdded, cero o más eventos ChildPolished y un evento ChildRemoved.

El evento ChildPolished se omite si un hijo es eliminado inmediatamente después de ser añadido. Si un hijo es pulido varias veces durante su construcción y destrucción, puedes recibir varios eventos hijo pulido para el mismo hijo, cada vez con una tabla virtual diferente.

Véase también event().

const QObjectList &QObject::children() const

Devuelve una lista de objetos hijo. La clase QObjectList se define en el fichero de cabecera <QObject> de la siguiente manera:

typedef QList<QObject*> QObjectList;

El primer hijo añadido es el objeto first de la lista y el último hijo añadido es el objeto last de la lista, es decir, los nuevos hijos se añaden al final.

Tenga en cuenta que el orden de la lista cambia cuando los hijos de QWidget son raised o lowered. Un widget que se sube se convierte en el último objeto de la lista, y un widget que se baja se convierte en el primer objeto de la lista.

Véase también findChild(), findChildren(), parent() y setParent().

[static] QMetaObject::Connection QObject::connect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type = Qt::AutoConnection)

Crea una conexión del tipo type desde signal en el objeto sender hasta method en el objeto receiver. Devuelve un "handle" de la conexión que puede utilizarse para desconectarla posteriormente.

El handle de la conexión será inválido si no puede crear la conexión, por ejemplo, los parámetros no eran válidos. Puede comprobar si QMetaObject::Connection es válido convirtiéndolo en un bool.

Esta función trabaja de la misma manera que connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type) pero utiliza QMetaMethod para especificar la señal y el método.

Ver también connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type).

[static] QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection)

Crea una conexión del tipo type desde signal en el objeto sender hasta method en el objeto receiver. Devuelve un "handle" de la conexión que puede utilizarse para desconectarla posteriormente.

Debe utilizar las macros SIGNAL() y SLOT() cuando especifique el signal y el method, por ejemplo:

QLabel *label = new QLabel;
QScrollBar *scrollBar = new QScrollBar;
QObject::connect(scrollBar, SIGNAL(valueChanged(int)),
                 label,  SLOT(setNum(int)));

Este ejemplo garantiza que la etiqueta muestre siempre el valor actual de la barra de desplazamiento. Tenga en cuenta que los parámetros signal y slots no deben contener ningún nombre de variable, sólo el tipo. Por ejemplo, lo siguiente no funcionaría y devolvería false:

// WRONG
QObject::connect(scrollBar, SIGNAL(valueChanged(int value)),
                 label, SLOT(setNum(int value)));

Una señal también puede conectarse a otra señal:

class MyWidget : public QWidget
{
    Q_OBJECT

public:
    MyWidget();

signals:
    void buttonClicked();

private:
    QPushButton *myButton;
};

MyWidget::MyWidget()
{
    myButton = new QPushButton(this);
    connect(myButton, SIGNAL(clicked()),
            this, SIGNAL(buttonClicked()));
}

En este ejemplo, el constructor MyWidget retransmite una señal desde una variable miembro privada, y la hace disponible bajo un nombre que se relaciona con MyWidget.

Una señal puede conectarse a muchas ranuras y señales. Muchas señales pueden estar conectadas a una ranura.

Si una señal está conectada a varias ranuras, las ranuras se activan en el mismo orden en que se realizaron las conexiones, cuando se emite la señal.

La función devuelve un QMetaObject::Connection que representa un asa a una conexión si conecta con éxito la señal a la ranura. El asa de conexión no será válida si no puede crear la conexión, por ejemplo, si QObject no puede verificar la existencia de signal o method, o si sus firmas no son compatibles. Puedes comprobar si el manejador es válido convirtiéndolo en un bool.

Por defecto, se emite una señal por cada conexión que realices; se emiten dos señales por conexiones duplicadas. Puedes romper todas estas conexiones con una sola llamada a disconnect(). Si pasa el Qt::UniqueConnection type , la conexión sólo se realizará si no es un duplicado. Si ya hay un duplicado (exactamente la misma señal al mismo slot en los mismos objetos), la conexión fallará y connect devolverá un QMetaObject::Connection inválido.

El parámetro opcional type describe el tipo de conexión a establecer. En particular, determina si una señal concreta se entrega a una ranura inmediatamente o se pone en cola para su entrega en un momento posterior. Si la señal se pone en cola, los parámetros deben ser de tipos conocidos por el sistema de meta-objetos de Qt, porque Qt necesita copiar los argumentos para almacenarlos en un evento entre bastidores. Si intentas usar una conexión en cola y obtienes el mensaje de error

QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)

llame a qRegisterMetaType() para registrar el tipo de datos antes de establecer la conexión.

Nota: Esta función es thread-safe.

Véase también disconnect(), sender(), qRegisterMetaType(), Q_DECLARE_METATYPE(), y Diferencias entre las conexiones basadas en cadenas y las basadas en funtores.

[static] template <typename PointerToMemberFunction, typename Functor> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, Functor functor)

Crea una conexión desde signal en el objeto sender a functor, y devuelve un handle a la conexión.

La señal debe ser una función declarada como señal en la cabecera. La función de ranura puede ser cualquier función o functor que pueda conectarse a la señal. Una función de ranura puede conectarse a una señal dada si la señal tiene al menos tantos argumentos como la función de ranura. Debe existir una conversión implícita entre los tipos de los argumentos correspondientes en la señal y la ranura.

Ejemplo:

void someFunction();
//...
void someOtherFunction()
{
    QPushButton *button = new QPushButton;
    QObject::connect(button, &QPushButton::clicked, someFunction);
}

También pueden utilizarse expresiones lambda:

    QByteArray page = "...";
    QTcpSocket *socket = new QTcpSocket;
    socket->connectToHost("qt-project.org", 80);
    QObject::connect(socket, &QTcpSocket::connected, [=] () {
            socket->write("GET " + page + "\r\n");
        });

La conexión se desconectará automáticamente si se destruye el emisor. Sin embargo, debes tener cuidado de que cualquier objeto utilizado dentro del functor siga vivo cuando se emita la señal.

Por esta razón, se recomienda utilizar la sobrecarga de connect() que también toma un QObject como receptor/contexto. Es posible desactivar el uso de la sobrecarga sin contexto definiendo la macro QT_NO_CONTEXTLESS_CONNECT.

Las funciones sobrecargadas pueden resolverse con ayuda de qOverload.

Nota: Esta función es thread-safe.

QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type = Qt::AutoConnection) const

Conecta signal desde el objeto sender al method de este objeto.

Equivale a connect(sender, signal, this, method, type).

Cada conexión que se realiza emite una señal, por lo que las conexiones duplicadas emiten dos señales. Puede romper una conexión utilizando disconnect().

Nota: Esta función es segura para hilos.

Véase también disconnect().

[static] template <typename PointerToMemberFunction, typename Functor> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection)

Crea una conexión de un type dado desde signal en el objeto sender a functor para ser colocado en un bucle de eventos específico de context, y devuelve un handle a la conexión.

La señal debe ser una función declarada como señal en la cabecera. La función de ranura puede ser cualquier función o functor que pueda conectarse a la señal. Una función de ranura puede conectarse a una señal dada si la señal tiene al menos tantos argumentos como la función de ranura. Debe existir una conversión implícita entre los tipos de los argumentos correspondientes en la señal y la ranura.

Ejemplo:

void someFunction();
//...
void someOtherFunction()
{
    QPushButton *button = new QPushButton;
    QObject::connect(button, &QPushButton::clicked, this, someFunction, Qt::QueuedConnection);
}

También pueden utilizarse expresiones lambda:

QByteArray page = "...";
QTcpSocket *socket = new QTcpSocket;
socket->connectToHost("qt-project.org", 80);
QObject::connect(socket, &QTcpSocket::connected, this, [=] () {
        socket->write("GET " + page + "\r\n");
    }, Qt::AutoConnection);

La conexión se desconectará automáticamente si se destruye el emisor o el contexto. Sin embargo, debes tener cuidado de que cualquier objeto utilizado dentro del functor siga vivo cuando se emita la señal.

Las funciones sobrecargadas pueden resolverse con ayuda de qOverload.

Nota: Esta función es thread-safe.

[static] template <typename PointerToMemberFunction> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type = Qt::AutoConnection)

Crea una conexión del tipo type desde signal en el objeto sender hasta method en el objeto receiver. Devuelve un "handle" a la conexión que puede utilizarse para desconectarla posteriormente.

La señal debe ser una función declarada como señal en la cabecera. La función de ranura puede ser cualquier función miembro que pueda conectarse a la señal. Una ranura puede conectarse a una señal dada si la señal tiene al menos tantos argumentos como la ranura, y existe una conversión implícita entre los tipos de los argumentos correspondientes en la señal y la ranura.

Ejemplo:

QLabel *label = new QLabel;
QLineEdit *lineEdit = new QLineEdit;
QObject::connect(lineEdit, &QLineEdit::textChanged,
                label,  &QLabel::setText);

Este ejemplo garantiza que la etiqueta muestre siempre el texto de edición de la línea actual.

Una señal puede conectarse a muchas ranuras y señales. Muchas señales pueden conectarse a una ranura.

Si una señal está conectada a varias ranuras, las ranuras se activan en el mismo orden en que se realizó la conexión, cuando se emite la señal.

La función devuelve un asa a una conexión si conecta con éxito la señal a la ranura. El asa de conexión no será válida si no puede crear la conexión, por ejemplo, si QObject no puede verificar la existencia de signal (si no se declaró como una señal) Puede comprobar si QMetaObject::Connection es válida convirtiéndola en un bool.

Por defecto, se emite una señal por cada conexión que realices; se emiten dos señales por conexiones duplicadas. Puedes romper todas estas conexiones con una sola llamada a disconnect(). Si pasa el Qt::UniqueConnection type , la conexión sólo se realizará si no es un duplicado. Si ya hay un duplicado (exactamente la misma señal a exactamente la misma ranura en los mismos objetos), la conexión fallará y connect devolverá un QMetaObject::Connection inválido.

El parámetro opcional type describe el tipo de conexión a establecer. En concreto, determina si una señal concreta se envía a una ranura inmediatamente o se pone en cola para su envío en otro momento. Si la señal se pone en cola, los parámetros deben ser de tipos conocidos por el sistema de meta-objetos de Qt, porque Qt necesita copiar los argumentos para almacenarlos en un evento entre bastidores. Si intentas usar una conexión en cola y obtienes el mensaje de error

QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)

asegúrese de declarar el tipo de argumento con Q_DECLARE_METATYPE

Las funciones sobrecargadas pueden resolverse con la ayuda de qOverload.

Nota: Esta función es thread-safe.

Vea también Diferencias entre Conexiones Basadas en Cadenas y Conexiones Basadas en Functores.

[virtual protected] void QObject::connectNotify(const QMetaMethod &signal)

Esta función virtual es llamada cuando algo ha sido conectado a signal en este objeto.

Si desea comparar signal con una señal específica, puede utilizar QMetaMethod::fromSignal() como se indica a continuación:

    if (signal == QMetaMethod::fromSignal(&MyObject::valueChanged)) {
        // signal is valueChanged
    }

Véase también connect() y disconnectNotify().

[virtual protected] void QObject::customEvent(QEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos personalizados. Los eventos personalizados son eventos definidos por el usuario con un valor de tipo al menos tan grande como el elemento QEvent::User del enum QEvent::Type, y es típicamente una subclase QEvent. El evento se pasa en el parámetro event.

Véase también event() y QEvent.

[slot] void QObject::deleteLater()

Programa la eliminación de este objeto.

El objeto se borrará cuando el control vuelva al bucle de eventos. Si el bucle de eventos no se está ejecutando cuando se llama a esta función (por ejemplo, se llama a deleteLater() en un objeto antes de QCoreApplication::exec()), el objeto se borrará una vez que se inicie el bucle de eventos. Si se llama a deleteLater() después de que el bucle de eventos principal se haya detenido, el objeto no se borrará. Si se llama a deleteLater() en un objeto que vive en un hilo sin bucle de eventos en ejecución, el objeto será destruido cuando el hilo termine.

Un patrón común cuando se utiliza un trabajador QObject en un QThread es conectar la señal finished() del hilo a la ranura deleteLater() del trabajador para asegurarse de que se elimina de forma segura:

connect(thread, &QThread::finished, worker, &QObject::deleteLater);

Ten en cuenta que entrar y salir de un nuevo bucle de eventos (por ejemplo, abriendo un diálogo modal) no realizará el borrado diferido; para que el objeto sea borrado, el control debe volver al bucle de eventos desde el que se llamó a deleteLater(). Esto no se aplica a los objetos borrados mientras se estaba ejecutando un bucle de eventos anidado anterior: el bucle de eventos de Qt borrará esos objetos tan pronto como se inicie el nuevo bucle de eventos anidado.

En situaciones en las que Qt no esté manejando el despachador de eventos a través de, por ejemplo, QCoreApplication::exec() o QEventLoop::exec(), los borrados diferidos no se procesarán automáticamente. Para asegurar el borrado diferido en este escenario, se puede utilizar la siguiente solución:

const auto *eventDispatcher = QThread::currentThread()->eventDispatcher();
QObject::connect(eventDispatcher, &QAbstractEventDispatcher::aboutToBlock,
    QThread::currentThread(), []{
        if (QThread::currentThread()->loopLevel() == 0)
            QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
    }
);

Nota: Esta función es segura para los hilos.

Véase también destroyed() y QPointer.

[signal] void QObject::destroyed(QObject *obj = nullptr)

Esta señal se emite inmediatamente antes de que el objeto obj sea destruido, después de que cualquier instancia de QPointer haya sido notificada, y no puede ser bloqueada.

Todos los hijos del objeto se destruyen inmediatamente después de que se emita esta señal.

Véase también deleteLater() y QPointer.

[static] bool QObject::disconnect(const QMetaObject::Connection &connection)

Desconectar una conexión.

Si la dirección connection no es válida o ya ha sido desconectada, no hace nada y devuelve false.

Véase también connect().

[static] bool QObject::disconnect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method)

Desconecta signal en el objeto sender de method en el objeto receiver. Devuelve true si la conexión se ha roto con éxito; en caso contrario devuelve false.

Esta función ofrece las mismas posibilidades que disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method) pero utiliza QMetaMethod para representar la señal y el método a desconectar.

Adicionalmente esta función devuelve false y ninguna señal y ranuras desconectadas si:

1. signal no es miembro de la clase emisora o de una de sus clases padre.
2. method no es miembro de la clase receptora o de una de sus clases padre.
3. signal la instancia no representa una señal.

Para evitar desajustes, almacene el manejador de conexión devuelto por connect(), y utilícelo en la llamada a disconnect().

QMetaMethod() puede utilizarse como comodín en el sentido "cualquier señal" o "cualquier ranura del objeto receptor". Del mismo modo nullptr puede utilizarse para receiver en el sentido de "cualquier objeto receptor". En este caso el método también debería ser QMetaMethod(). El parámetro sender nunca debería ser nullptr.

Ver también disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method).

[static] bool QObject::disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method)

Desconecta signal en el objeto sender de method en el objeto receiver. Devuelve true si la conexión se ha roto con éxito; en caso contrario devuelve false.

Una conexión de ranura de señal se elimina cuando se destruye cualquiera de los objetos implicados.

disconnect() se utiliza normalmente de tres formas, como demuestran los siguientes ejemplos.

1. Desconecta todo lo conectado a las señales de un objeto:

       QObject::disconnect(myObject, nullptr, nullptr, nullptr);

   equivalente a la función sobrecargada no estática

       myObject->disconnect();

2. Desconectar todo lo conectado a una señal específica:

       QObject::disconnect(myObject, SIGNAL(mySignal()), nullptr, nullptr);

   equivalente a la función sobrecargada no estática

       myObject->disconnect(SIGNAL(mySignal()));

3. Desconectar un receptor específico:

       QObject::disconnect(myObject, nullptr, myReceiver, nullptr);

   equivalente a la función sobrecargada no estática

       myObject->disconnect(myReceiver);

Para evitar desajustes, almacene el manejador de conexión devuelto por connect(), y utilícelo en la llamada a disconnect().

nullptr puede utilizarse como comodín, lo que significa "cualquier señal", "cualquier objeto receptor" o "cualquier ranura del objeto receptor", respectivamente.

sender nunca puede ser nullptr. (No se pueden desconectar señales de más de un objeto en una sola llamada).

Si signal es nullptr, desconecta receiver y method de cualquier señal. Si no, sólo se desconecta la señal especificada.

Si receiver es nullptr, desconecta cualquier cosa conectada a signal. Si no, no se desconectan las ranuras de los objetos que no sean receiver.

Si method es nullptr, desconecta todo lo que esté conectado a receiver. Si no, sólo se desconectan las ranuras denominadas method, y el resto de ranuras se dejan solas. El method debe ser nullptr si se omite receiver, por lo que no se puede desconectar una ranura con nombre específico en todos los objetos.

Nota: Esta función es thread-safe.

Véase también connect().

bool QObject::disconnect(const QObject *receiver, const char *method = nullptr) const

Desconecta todas las señales de este objeto de receiver's method.

Para evitar desajustes, almacene el manejador de conexión devuelto por connect(), y utilícelo en la llamada a disconnect().

Una conexión de ranura de señal se elimina cuando se destruye cualquiera de los objetos implicados.

bool QObject::disconnect(const char *signal = nullptr, const QObject *receiver = nullptr, const char *method = nullptr) const

Desconecta signal de method de receiver.

Para evitar desajustes, almacene el manejador de conexión devuelto por connect(), y utilícelo en la llamada a disconnect().

Una conexión de ranura de señal se elimina cuando se destruye cualquiera de los objetos implicados.

Nota: Esta función es thread-safe.

[static] template <typename PointerToMemberFunction> bool QObject::disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method)

Desconecta signal en el objeto sender de method en el objeto receiver. Devuelve true si la conexión se ha roto con éxito; en caso contrario devuelve false.

Una conexión de ranura de señal se elimina cuando se destruye cualquiera de los objetos implicados.

disconnect() se utiliza normalmente de tres formas, como demuestran los siguientes ejemplos.

1. Desconecta todo lo conectado a las señales de un objeto:

       QObject::disconnect(myObject, nullptr, nullptr, nullptr);

2. Desconecta todo lo conectado a una señal específica:

       QObject::disconnect(myObject, &MyObject::mySignal, nullptr, nullptr);

3. Desconectar un receptor específico:

       QObject::disconnect(myObject, nullptr, myReceiver, nullptr);

4. Desconectar una conexión de una señal específica a una ranura específica:

       QObject::disconnect(lineEdit, &QLineEdit::textChanged,
                       label,  &QLabel::setText);

nullptr puede utilizarse como comodín, lo que significa "cualquier señal", "cualquier objeto receptor" o "cualquier ranura del objeto receptor", respectivamente.

sender nunca puede ser nullptr. (No se pueden desconectar señales de más de un objeto en una sola llamada).

Si signal es nullptr, desconecta receiver y method de cualquier señal. Si no, sólo se desconecta la señal especificada.

Si receiver es nullptr, desconecta cualquier cosa conectada a signal. Si no, sólo se desconectan las ranuras del receptor especificado. disconnect() con un receiver no nulo también desconecta las funciones de ranura que estaban conectadas con receiver como su objeto de contexto.

Si method es nullptr, desconecta cualquier cosa que esté conectada a receiver. Si no, sólo se desconectan las ranuras llamadas method, y el resto de ranuras se dejan solas. El method debe ser nullptr si se omite receiver, por lo que no se puede desconectar una ranura con nombre específico en todos los objetos.

Nota: Esta función es segura para hilos.

Véase también connect().

[virtual protected] void QObject::disconnectNotify(const QMetaMethod &signal)

Esta función virtual es llamada cuando algo ha sido desconectado de signal en este objeto.

Véase connectNotify() para un ejemplo de cómo comparar signal con una señal específica.

Si todas las señales fueron desconectadas de este objeto (por ejemplo, el argumento de señal a disconnect() era nullptr), disconnectNotify() sólo es llamada una vez, y signal será un QMetaMethod inválido (QMetaMethod::isValid() devuelve false).

Véase también disconnect() y connectNotify().

void QObject::dumpObjectInfo() const

Vuelca información sobre las conexiones de señal, etc. de este objeto a la salida de depuración.

Véase también dumpObjectTree().

void QObject::dumpObjectTree() const

Vuelca un árbol de hijos a la salida de depuración.

Véase también dumpObjectInfo().

QList<QByteArray> QObject::dynamicPropertyNames() const

Devuelve los nombres de todas las propiedades que se han añadido dinámicamente al objeto mediante setProperty().

[virtual] bool QObject::event(QEvent *e)

Esta función virtual recibe eventos a un objeto y debe devolver true si el evento e fue reconocido y procesado.

La función event() puede ser reimplementada para personalizar el comportamiento de un objeto.

Asegúrese de llamar a la implementación de la clase de eventos padre para todos los eventos que no haya manejado.

Ejemplo:

class MyClass : public QWidget
{
    Q_OBJECT

public:
    MyClass(QWidget *parent = nullptr);
    ~MyClass();

    bool event(QEvent* ev) override
    {
        if (ev->type() == QEvent::PolishRequest) {
            // overwrite handling of PolishRequest if any
            doThings();
            return true;
        } else  if (ev->type() == QEvent::Show) {
            // complement handling of Show if any
            doThings2();
            QWidget::event(ev);
            return true;
        }
        // Make sure the rest of events are handled
        return QWidget::event(ev);
    }
};

Ver también installEventFilter(), timerEvent(), QCoreApplication::sendEvent(), y QCoreApplication::postEvent().

[virtual] bool QObject::eventFilter(QObject *watched, QEvent *event)

Filtra los eventos si este objeto se ha instalado como filtro de eventos para el objeto watched.

En su reimplementación de esta función, si desea filtrar el event, es decir, impedir que se siga gestionando, devuelva true; en caso contrario, devuelva false.

Ejemplo:

clase MainWindow : public QMainWindow
{public: MainWindow();protected: bool eventFilter(QObject*obj, QEvent *ev) override;private:    QTextEdit *textEdit; }; MainWindow::MainWindow() { textEdit = new QTextEdit; setCentralWidget(textEdit);  textEdit->installEventFilter(this); }bool MainWindow::eventFilter(QObject*obj, QEvent *event) { if (obj == textEdit) { if (event->type() == QEvent::KeyPress) { QKeyEvent *teclaEvento =  static_cast<QKeyEvent*>(evento);            qDebug() << "Ate key press" << keyEvent->key();
           return true; } else { return false; } } else { // pasa el evento a la clase padre return QMainWindow::eventFilter(obj, event); } }

Observa en el ejemplo anterior que los eventos no manejados se pasan a la función eventFilter() de la clase base, ya que la clase base podría haber reimplementado eventFilter() para sus propios propósitos internos.

Algunos eventos, como QEvent::ShortcutOverride deben ser aceptados explícitamente (llamando a accept() sobre ellos) para evitar su propagación.

Véase también installEventFilter().

template <typename T> T QObject::findChild(QAnyStringView name, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Devuelve el hijo de este objeto que se puede convertir al tipo T y que se llama name, o nullptr si no existe tal objeto. Un argumento name nulo hace que se busquen todos los objetos. Un argumento name vacío y no nulo busca sólo objetos cuyo objectName esté vacío. La búsqueda se realiza de forma recursiva, a menos que options especifique la opción FindDirectChildrenOnly.

Si hay más de un hijo que coincide con la búsqueda, se devuelve el antepasado más directo. Si hay varios ancestros más directos, se devolverá el primer hijo en children(). En ese caso, es mejor utilizar findChildren() para obtener la lista completa de todos los hijos.

Este ejemplo devuelve un QPushButton hijo de parentWidget llamado "button1", aunque el botón no sea hijo directo del padre:

QPushButton *button = parentWidget->findChild<QPushButton *>("button1");

Este ejemplo devuelve un QListWidget hijo de parentWidget:

QListWidget *list = parentWidget->findChild<QListWidget *>();

Este ejemplo devuelve un QPushButton hijo de parentWidget (su padre directo) llamado "button1":

QPushButton *button = parentWidget->findChild<QPushButton *>("button1", Qt::FindDirectChildrenOnly);

Este ejemplo devuelve un QListWidget hijo de parentWidget, su padre directo:

QListWidget *list = parentWidget->findChild<QListWidget *>(Qt::FindDirectChildrenOnly);

Véase también findChildren().

[since 6.7] template <typename T> T QObject::findChild(Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Devuelve el hijo de este objeto que se puede convertir al tipo T, o nullptr si no existe tal objeto. La búsqueda se realiza de forma recursiva, a menos que options especifique la opción FindDirectChildrenOnly.

Si hay más de un hijo que coincida con la búsqueda, se devuelve el antepasado más directo. Si hay varios ancestros más directos, se devolverá el primer hijo en children(). En ese caso, es mejor utilizar findChildren() para obtener la lista completa de todos los hijos.

Esta función se introdujo en Qt 6.7.

Véase también findChildren().

template <typename T> QList<T> QObject::findChildren(QAnyStringView name, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Devuelve todos los hijos de este objeto con el name dado que se pueden convertir al tipo T, o una lista vacía si no hay tales objetos. Un argumento name nulo hace que se busquen todos los objetos, uno vacío sólo aquellos cuyo objectName esté vacío. La búsqueda se realiza de forma recursiva, a menos que options especifique la opción FindDirectChildrenOnly.

El siguiente ejemplo muestra cómo encontrar una lista de QWidgets hijos del parentWidget especificado llamado widgetname:

QList<QWidget *> widgets = parentWidget->findChildren<QWidget *>("widgetname");

Este ejemplo devuelve todos los QPushButtons que son hijos de parentWidget:

QList<QPushButton *> allPButtons = parentWidget->findChildren<QPushButton *>();

Este ejemplo devuelve todos los QPushButtons que son hijos inmediatos de parentWidget:

QList<QPushButton *> childButtons = parentWidget.findChildren<QPushButton *>(Qt::FindDirectChildrenOnly);

Véase también findChild().

[since 6.3] template <typename T> QList<T> QObject::findChildren(Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Devuelve todos los hijos de este objeto que se pueden convertir al tipo T, o una lista vacía si no existen tales objetos. La búsqueda se realiza de forma recursiva, a menos que options especifique la opción FindDirectChildrenOnly.

Esta función se introdujo en Qt 6.3.

Véase también findChild().

template <typename T> QList<T> QObject::findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

Devuelve los hijos de este objeto que se pueden convertir al tipo T y que tienen nombres que coinciden con la expresión regular re, o una lista vacía si no hay tales objetos. La búsqueda se realiza recursivamente, a menos que options especifique la opción FindDirectChildrenOnly.

bool QObject::inherits(const char *className) const

Devuelve true si este objeto es una instancia de una clase que hereda de className o de una subclase de QObject que hereda de className; en caso contrario devuelve false.

Se considera que una clase se hereda a sí misma.

Ejemplo:

QTimer *timer = new QTimer;         // QTimer inherits QObject
timer->inherits("QTimer");          // returns true
timer->inherits("QObject");         // returns true
timer->inherits("QAbstractButton"); // returns false

// QVBoxLayout inherits QObject and QLayoutItem
QVBoxLayout *layout = new QVBoxLayout;
layout->inherits("QObject");        // returns true
layout->inherits("QLayoutItem");    // returns true (even though QLayoutItem is not a QObject)

Si necesita determinar si un objeto es una instancia de una clase en particular con el propósito de hacer un casting, considere usar qobject_cast<Tipo *>(objeto) en su lugar.

Véase también metaObject() y qobject_cast().

void QObject::installEventFilter(QObject *filterObj)

Instala un filtro de eventos filterObj en este objeto. Por ejemplo:

monitoredObj->installEventFilter(filterObj);

Un filtro de eventos es un objeto que recibe todos los eventos que se envían a este objeto. El filtro puede detener el evento o reenviarlo a este objeto. El filtro de eventos filterObj recibe eventos a través de su función eventFilter(). La función eventFilter() debe devolver true si el evento debe ser filtrado, (es decir, detenido); en caso contrario debe devolver false.

Si se instalan varios filtros de eventos en un mismo objeto, se activa primero el filtro que se instaló en último lugar.

Si ya se ha instalado filterObj para este objeto, esta función lo desplaza para que actúe como si se hubiera instalado en último lugar.

Aquí hay una clase KeyPressEater que se come las pulsaciones de teclas de sus objetos monitorizados:

clase KeyPressEater : public QObject
{ Q_OBJECTpublic: KeyPressEater(QObject *parent = nullptr) : QObject(parent) {}//...protected: bool eventFilter(QObject*obj, QEvent *event) override; };bool KeyPressEater::eventFilter(QObject*obj, QEvent *event) { if (event->type() == QEvent::KeyPress) { QKeyEvent *teclaEvento =  static_cast<QKeyEvent *>(evento);        qDebug("Ate key press %d", keyEvent->key());
       return true; } else { // procesamiento estándar de eventos return QObject::eventFilter(obj, event); } }

Y aquí está cómo instalarlo en dos widgets:

KeyPressEater *keyPressEater = new KeyPressEater(this);
QPushButton *pushButton = new QPushButton(this);
QListView *listView = new QListView(this);

pushButton->installEventFilter(keyPressEater);
listView->installEventFilter(keyPressEater);

La clase QShortcut, por ejemplo, utiliza esta técnica para interceptar las pulsaciones de teclas de acceso directo.

Ten en cuenta que el objeto filtrador debe estar en el mismo hilo que este objeto. Si filterObj está en un hilo diferente, esta función no hace nada. Si filterObj o este objeto se mueven a un hilo diferente después de llamar a esta función, el filtro de eventos no será llamado hasta que ambos objetos vuelvan a tener la misma afinidad de hilo ( no se elimina).

Ver también removeEventFilter(), eventFilter(), y event().

[noexcept, since 6.11] bool QObject::isQmlExposed() const

Devuelve si el objeto ha sido creado por el motor QML o si la propiedad se ha establecido explícitamente a través de QJSEngine::setObjectOwnership().

Esta función se introdujo en Qt 6.11.

[since 6.4] bool QObject::isQuickItemType() const

Devuelve true si el objeto es un QQuickItem; en caso contrario devuelve false.

Llamar a esta función es equivalente a llamar a inherits("QQuickItem"), excepto que es mucho más rápido.

Esta función se introdujo en Qt 6.4.

[protected] bool QObject::isSignalConnected(const QMetaMethod &signal) const

Devuelve true si el signal está conectado al menos a un receptor, en caso contrario devuelve false.

signal debe ser un miembro señal de este objeto, de lo contrario el comportamiento es indefinido.

    static const QMetaMethod valueChangedSignal = QMetaMethod::fromSignal(&MyObject::valueChanged);
    if (QObject::isSignalConnected(valueChangedSignal)) {
        QByteArray data;
        data = get_the_value();       // expensive operation
        emit valueChanged(data);
    }

Como ilustra el fragmento de código anterior, puede utilizar esta función para evitar operaciones costosas o emitir una señal que nadie escucha.

Véase también receivers().

bool QObject::isWidgetType() const

Devuelve true si el objeto es un widget; en caso contrario devuelve false.

Llamar a esta función es equivalente a llamar a inherits("QWidget"), excepto que es mucho más rápido.

bool QObject::isWindowType() const

Devuelve true si el objeto es una ventana; en caso contrario devuelve false.

Llamar a esta función es equivalente a llamar a inherits("QWindow"), excepto que es mucho más rápido.

void QObject::killTimer(int id)

Acaba con el temporizador con identificador de temporizador, id.

El identificador del temporizador es devuelto por startTimer() cuando se inicia un evento de temporizador.

Véase también timerEvent() y startTimer().

[since 6.8] void QObject::killTimer(Qt::TimerId id)

Esta función se introdujo en Qt 6.8.

[virtual] const QMetaObject *QObject::metaObject() const

Devuelve un puntero al metaobjeto de este objeto.

Un meta-objeto contiene información sobre una clase que hereda QObject, por ejemplo, nombre de la clase, nombre de la superclase, propiedades, señales y ranuras. Cada subclase de QObject que contenga la macro Q_OBJECT tendrá un metaobjeto.

La información del metaobjeto es necesaria para el mecanismo de conexión señal/ranura y el sistema de propiedades. La función inherits() también hace uso del meta-objeto.

Si no dispone de un puntero a una instancia de objeto real pero desea acceder al metaobjeto de una clase, puede utilizar staticMetaObject.

Ejemplo:

QObject *obj = new QPushButton;
obj->metaObject()->className();             // returns "QPushButton"

QPushButton::staticMetaObject.className();  // returns "QPushButton"

Véase también staticMetaObject.

bool QObject::moveToThread(QThread *targetThread)

Cambia la afinidad de hilos para este objeto y sus hijos y devuelve true en caso de éxito. El objeto no puede ser movido si tiene un padre. El procesamiento de eventos continuará en targetThread.

Para mover un objeto al hilo principal, utilice QApplication::instance() para recuperar un puntero a la aplicación actual y, a continuación, utilice QApplication::thread() para recuperar el hilo en el que vive la aplicación. Por ejemplo:

myObject->moveToThread(QApplication::instance()->thread());

Si targetThread es nullptr, todo el procesamiento de eventos para este objeto y sus hijos se detiene, puesto que ya no están asociados a ningún hilo.

Tenga en cuenta que todos los temporizadores activos para el objeto se reiniciarán. Los temporizadores se detienen primero en el subproceso actual y se reinician (con el mismo intervalo) en targetThread. Como resultado, mover constantemente un objeto entre subprocesos puede posponer indefinidamente los eventos del temporizador.

Se envía un evento QEvent::ThreadChange a este objeto justo antes de que se cambie la afinidad del hilo. Puedes manejar este evento para realizar cualquier procesamiento especial. Tenga en cuenta que cualquier nuevo evento que se envíe a este objeto será manejado en targetThread, siempre que no sea nullptr: cuando es nullptr, no puede ocurrir ningún procesamiento de eventos para este objeto o sus hijos, ya que ya no están asociados a ningún hilo.

En las versiones de Qt anteriores a la 6.7, esta función no tenía valor de retorno (void).

Véase también thread().

[private signal] void QObject::objectNameChanged(const QString &objectName)

Esta señal se emite después de cambiar el nombre del objeto. El nuevo nombre del objeto se pasa como objectName.

Véase también QObject::objectName.

QObject *QObject::parent() const

Devuelve un puntero al objeto padre.

Véase también setParent() y children().

QVariant QObject::property(const char *name) const

Devuelve el valor de la propiedad name del objeto.

Si no existe tal propiedad, la variante devuelta no es válida.

La información sobre todas las propiedades disponibles se proporciona a través de metaObject() y dynamicPropertyNames().

Véase también setProperty(), QVariant::isValid(), metaObject() y dynamicPropertyNames().

[protected] int QObject::receivers(const char *signal) const

Devuelve el número de receptores conectados a signal.

Dado que tanto las ranuras como las señales pueden utilizarse como receptores de señales, y que las mismas conexiones pueden realizarse muchas veces, el número de receptores es el mismo que el número de conexiones realizadas desde esta señal.

Al llamar a esta función, puede utilizar la macro SIGNAL() para pasar una señal específica:

if (receivers(SIGNAL(valueChanged(QByteArray))) > 0) {
    QByteArray data;
    get_the_value(&data);       // expensive operation
    emit valueChanged(data);
}

Como ilustra el fragmento de código anterior, puede utilizar esta función para evitar operaciones costosas o emitir una señal que nadie escuche.

Véase también isSignalConnected().

void QObject::removeEventFilter(QObject *obj)

Elimina un objeto de filtro de eventos obj de este objeto. La petición es ignorada si tal filtro de eventos no ha sido instalado.

Todos los filtros de eventos para este objeto se eliminan automáticamente cuando se destruye este objeto.

Siempre es seguro eliminar un filtro de eventos, incluso durante la activación del filtro de eventos (es decir, desde la función eventFilter()).

Véase también installEventFilter(), eventFilter(), y event().

[protected] QObject *QObject::sender() const

Devuelve un puntero al objeto que envió la señal, si se llama en una ranura activada por una señal; en caso contrario, devuelve nullptr. El puntero sólo es válido durante la ejecución de la ranura que llama a esta función desde el contexto de subproceso de este objeto.

El puntero devuelto por esta función pierde su validez si el emisor es destruido, o si la ranura se desconecta de la señal del emisor.

Véase también senderSignalIndex().

[protected] int QObject::senderSignalIndex() const

Devuelve el índice del metamétodo de la señal que llamó a la ranura actualmente en ejecución, que es un miembro de la clase devuelta por sender(). Si se llama fuera de una ranura activada por una señal, se devuelve -1.

Para las señales con parámetros predeterminados, esta función siempre devolverá el índice con todos los parámetros, independientemente de cuál se utilizó con connect(). Por ejemplo, la señal destroyed(QObject *obj = \nullptr) tendrá dos índices diferentes (con y sin el parámetro), pero esta función siempre devolverá el índice con un parámetro. Esto no se aplica cuando se sobrecargan señales con diferentes parámetros.

Véase también sender(), QMetaObject::indexOfSignal(), y QMetaObject::method().

void QObject::setObjectName(const QString &name)

Establece el nombre del objeto en name.

Véase también objectName().

[since 6.4] void QObject::setObjectName(QAnyStringView name)

Esta función se introdujo en Qt 6.4.

void QObject::setParent(QObject *parent)

Hace que el objeto sea hijo de parent.

Véase también parent() y children().

bool QObject::setProperty(const char *name, const QVariant &value)

Establece el valor de la propiedad name del objeto a value.

Si la propiedad está definida en la clase utilizando Q_PROPERTY entonces se devuelve true en caso de éxito y false en caso contrario. Si la propiedad no está definida usando Q_PROPERTY, y por lo tanto no está listada en el meta-objeto, se añade como una propiedad dinámica y se devuelve false.

La información sobre todas las propiedades disponibles se proporciona a través de metaObject() y dynamicPropertyNames().

Las propiedades dinámicas se pueden volver a consultar mediante property() y se pueden eliminar estableciendo el valor de la propiedad en un valor no válido QVariant. Si se cambia el valor de una propiedad dinámica, se envía un QDynamicPropertyChangeEvent al objeto.

Nota: Las propiedades dinámicas que empiezan por "_q_" están reservadas para fines internos.

Véase también property(), metaObject(), dynamicPropertyNames() y QMetaProperty::write().

[since 6.6] bool QObject::setProperty(const char *name, QVariant &&value)

Esta función se introdujo en Qt 6.6.

[noexcept] bool QObject::signalsBlocked() const

Devuelve true si las señales están bloqueadas; en caso contrario devuelve false.

Las señales no están bloqueadas por defecto.

Véase también blockSignals() y QSignalBlocker.

int QObject::startTimer(int interval, Qt::TimerType timerType = Qt::CoarseTimer)

Esta es una función sobrecargada que iniciará un temporizador de tipo timerType y un tiempo de espera de interval milisegundos. Esto es equivalente a llamar:

startTimer(std::chrono::milliseconds{interval}, timerType);

A partir de Qt 6.10, establecer un intervalo negativo resultará en una advertencia en tiempo de ejecución y el valor se restablecerá a 1ms. Antes de Qt 6.10 un Temporizador Qt te permitía establecer un intervalo negativo pero se comportaba de forma sorprendente (por ejemplo parar el temporizador si estaba en marcha o no iniciarlo en absoluto).

Ver también timerEvent(), killTimer(), QChronoTimer, y QBasicTimer.

int QObject::startTimer(std::chrono::nanoseconds interval, Qt::TimerType timerType = Qt::CoarseTimer)

Inicia un temporizador y devuelve un identificador de temporizador, o devuelve cero si no pudo iniciar un temporizador.

Se producirá un evento de temporizador cada interval hasta que se llame a killTimer(). Si interval es igual a std::chrono::duration::zero(), entonces el evento del temporizador se produce una vez cada vez que el control vuelve al bucle de eventos, es decir, no hay más eventos nativos del sistema de ventanas que procesar.

A partir de Qt 6.10, establecer un intervalo negativo resultará en una advertencia en tiempo de ejecución y el valor se restablecerá a 1ms. Antes de Qt 6.10, un temporizador Qt permitía establecer un intervalo negativo pero se comportaba de forma sorprendente (por ejemplo, detenía el temporizador si estaba en marcha o no lo iniciaba en absoluto).

La función virtual timerEvent() es llamada con la clase de parámetro de evento QTimerEvent cuando ocurre un evento de temporizador. Reimplemente esta función para obtener eventos del temporizador.

Si se están ejecutando varios temporizadores, se puede utilizar el método QTimerEvent::id() para averiguar qué temporizador se activó.

Ejemplo:

clase MyObject : public QObject
{ Q_OBJECTpublic: MyObject(QObject *parent = nullptr); Q_SIGNALS: void valueChanged();protected: void timerEvent(QTimerEvent *event) override; }; MyObject::MyObject(QObject *parent) : QObject(parent) { using namespace std::chrono_literals; startTimer(50ms); startTimer(5s); startTimer(10min); startTimer(1h); }void MyObject::timerEvent(QTimerEvent * evento){
    qDebug() << "Timer ID:" << event->id();
}

Tenga en cuenta que la precisión del temporizador depende del sistema operativo y del hardware subyacentes.

El argumento timerType le permite personalizar la precisión del temporizador. Consulte Qt::TimerType para obtener información sobre los diferentes tipos de temporizadores. La mayoría de las plataformas soportan una precisión de 20 milisegundos; algunas proporcionan más. Si Qt no es capaz de entregar el número solicitado de eventos de temporizador, descartará silenciosamente algunos.

Las clases QTimer y QChronoTimer proporcionan una interfaz de programación de alto nivel con temporizadores de disparo único y señales de temporizador en lugar de eventos. También hay una clase QBasicTimer que es más ligera que QChronoTimer pero menos torpe que usar IDs de temporizador directamente.

    QObject *obj;
    //...
    const auto id = Qt::TimerId {obj->startTimer(100ms)};
    if (id != Qt::TimerId::Invalid)
    {
        // The timer has been started successfully
    }

Ver también timerEvent(), killTimer(), QChronoTimer, y QBasicTimer.

QThread *QObject::thread() const

Devuelve el hilo en el que vive el objeto.

Véase también moveToThread().

[virtual protected] void QObject::timerEvent(QTimerEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de temporizador para el objeto.

QChronoTimer proporciona interfaces de nivel superior para la funcionalidad del temporizador, y también información más general sobre los temporizadores. El evento del temporizador se pasa en el parámetro event.

Véase también startTimer(), killTimer(), y event().

[static] QString QObject::tr(const char *sourceText, const char *disambiguation = nullptr, int n = -1)

Devuelve una versión traducida de sourceText, opcionalmente basada en una cadena disambiguation y el valor de n para cadenas que contengan plurales; en caso contrario devuelve QString::fromUtf8(sourceText) si no se dispone de una cadena traducida apropiada.

Ejemplo:

void SpreadSheet::setupMenuBar()
{
    QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
    ...

Si se utiliza el mismo sourceText en diferentes funciones dentro del mismo contexto, se puede pasar una cadena de identificación adicional en disambiguation (nullptr por defecto).

Ejemplo:

MyWindow::MyWindow()
{
    QLabel *senderLabel = new QLabel(tr("Name:"));
    QLabel *recipientLabel = new QLabel(tr("Name:", "recipient"));
    ...

Véase Writing Source Code for Translation para una descripción detallada de los mecanismos de traducción de Qt en general, y la sección Disambiguate Identical Text para información sobre la desambiguación.

Ver también QCoreApplication::translate() e Internacionalización con Qt.