QObject Class

メンバ関数のドキュメント

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

親オブジェクトparent を持つオブジェクトを構築する。

オブジェクトの親は、オブジェクトの所有者とみなすことができる。例えば、dialog box は、それが含むOK とCancel ボタンの親です。

親オブジェクトのデストラクタは、すべての子オブジェクトを破棄します。

parent をnullptr に設定すると、親を持たないオブジェクトが構築されます。オブジェクトがウィジェットの場合、トップレベル・ウィンドウになります。

parent()、findChild()、findChildren()も 参照してください。

[virtual noexcept] QObject::~QObject()

オブジェクトを破棄し、すべての子オブジェクトを削除します。

オブジェクトとの間で送受信されるすべてのシグナルは自動的に切断され、オブジェクトに対する保留中のポスト・イベントはすべてイベント・キューから削除されます。ただし、QObject のサブクラスを直接削除するよりも、deleteLater() を使用した方が安全な場合が多いです。

deleteLater()も参照のこと 。

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

block が true の場合、このオブジェクトが発するシグナルはブロックされます（つまり、シグナルを発しても、そのオブジェクトに接続されているものは何も呼び出されません）。block が偽の場合、そのようなブロックは発生しません。

戻り値はsignalsBlocked() の前の値である。

このオブジェクトのシグナルがブロックされていても、destroyed() シグナルは発せられることに注意。

ブロックされている間に発せられたシグナルは、バッファリングされません。

signalsBlocked() およびQSignalBlockerも参照のこと 。

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

このイベント・ハンドラは、子イベントを受け取るためにサブクラスで再実装することができる。イベントはevent パラメータで渡されます。

QEvent::ChildAdded と イベントは、子が追加されたり削除されたりしたときにオブジェクトに送られます。どちらの場合も、子が であること、あるいは () が を返す場合は であることだけを頼りにすることができます（これは、 の場合は子がまだ完全に構築されておらず、 の場合はすでに破棄されている可能性があるためです）。QEvent::ChildRemoved QObject isWidgetType true QWidget ChildAdded ChildRemoved

QEvent::ChildPolished イベントは、子プロセスがポリッシュされたとき、またはポリッシュされた子プロセスが追加されたときに、ウィジェットに送信されます。子プロセスの polished イベントを受信した場合、通常、子プロセスの構築は完了しています。ただし、これは保証されるものではなく、ウィジェットのコンストラクタの実行中に複数の polished イベントが送られることがあります。

子ウィジェットごとに、ChildAdded イベントを 1 つ、ChildPolished イベントを 0 つ以上、ChildRemoved イベントを 1 つ受信します。

子ウィジェットが追加された直後に削除された場合、ChildPolished イベントは省略されます。子ウィジェットが構築中と破棄中に何度も磨かれる場合、同じ子ウィジェットに対して複数の磨かれた子ウィジェット・イベントを受け取ることがあります。

event()も参照してください 。

const QObjectList &QObject::children() const

子オブジェクトのリストを返します。QObjectList クラスは<QObject> ヘッダーファイルで以下のように定義されている：

typedef QList<QObject*> QObjectList;

最初に追加された子オブジェクトはリスト内のfirst 、最後に追加された子オブジェクトはリスト内のlast 。

QWidget の子がraised またはlowered の場合、リストの順序が変わることに注意してください。上げられたウィジェットはリストの最後のオブジェクトになり、下げられたウィジェットはリストの最初のオブジェクトになります。

findChild()、findChildren()、parent()、setParent()も参照 。

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

sender オブジェクトのsignal からreceiver オブジェクトのmethod へ、与えられたtype の接続を作成します。後で接続を切断するために使用できる、接続へのハンドルを返します。

Connectionハンドルは、例えばパラメータが無効であったなど、接続を作成できなかった場合には無効となります。QMetaObject::Connection が有効かどうかは、bool にキャストすることで確認できます。

この関数はconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type) と同じように動作しますが、シグナルとメソッドの指定にQMetaMethod を使用します。

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)

sender オブジェクトのsignal からreceiver オブジェクトのmethod へ、与えられたtype の接続を作成します。後で接続を切断するために使用できる接続へのハンドルを返します。

例えば、signal とmethod を指定する場合、SIGNAL() とSLOT() マクロを使用する必要があります：

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

この例では、ラベルが常に現在のスクロールバー値を表示するようにします。signalとslotsのパラメータには変数名を含めてはいけない。例えば、次のように指定すると動作せず、falseを返します：

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

シグナルは別のシグナルに接続することもできます：

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()));
}

この例では、MyWidget コンストラクタがプライベート・メンバ変数からシグナルをリレーし、MyWidget に関連する名前で利用できるようにしています。

シグナルは多くのスロットやシグナルに接続することができます。多くのシグナルを1つのスロットに接続することができます。

シグナルが複数のスロットに接続されている場合、シグナルが発信されると、接続された順番にスロットがアクティブになります。

この関数は、シグナルとスロットの接続に成功した場合、接続ハンドルを表すQMetaObject::Connection を返します。接続ハンドルは、例えば、QObject がsignal またはmethod の存在を確認できない場合や、それらの署名に互換性がない場合など、接続を作成できない場合には無効となります。ハンドルが有効かどうかは、ハンドルをboolにキャストすることで確認できます。

デフォルトでは、接続が行われるたびにシグナルが発行され、重複接続の場合は2つのシグナルが発行されます。これらの接続をすべて切断するには、disconnect （）を1回呼び出す。Qt::UniqueConnection type を渡すと、重複接続でない場合のみ接続が行われる。すでに重複している場合（同じオブジェクトのまったく同じスロットにまったく同じシグナル）、接続は失敗し、connectは無効なQMetaObject::Connection を返します。

オプションのtype パラメータは、確立する接続のタイプを記述します。特に、特定のシグナルを即座にスロットに配信するか、後で配信するためにキューに入れるかを決定します。シグナルがキューイングされる場合、Qtは裏で引数をコピーしてイベントに格納する必要があるため、パラメータはQtのメタオブジェクトシステムが知っている型でなければなりません。キューイングされた接続を使おうとして、エラーメッセージが表示された場合

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

接続を確立する前に、qRegisterMetaType() を呼び出してデータ型を登録してください。

注意：この関数はスレッド・セーフである。

disconnect()、sender()、qRegisterMetaType()、Q_DECLARE_METATYPE()、文字列ベース接続とファンクタ・ベース接続の違いも参照 。

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

この関数は connect() をオーバーロードしたものです。

sender オブジェクトのsignal からfunctor への接続を作成し、その接続へのハンドルを返します。

シグナルは、ヘッダーでシグナルとして宣言された関数でなければなりません。スロット関数は、シグナルに接続できる任意の関数またはファンクタである。スロット関数は、シグナルが少なくともスロット関数と同じ数の引数を持っていれば、与えられたシグナルに接続することができます。シグナルとスロットの対応する引数の型の間には暗黙の変換が存在しなければなりません。

例

void someFunction();
QPushButton *button = new QPushButton;
QObject::connect(button, &QPushButton::clicked, someFunction);

ラムダ式も使用できます：

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

送信者が破壊されると、接続は自動的に切断される。ただし、シグナルが発信されたときに、ファンクタ内で使用されているオブジェクトがまだ生きているように注意する必要があります。

このため、レシーバー／コンテキストとしてQObject も受け取る connect() のオーバーロードを使用することを推奨する。QT_NO_CONTEXTLESS_CONNECT マクロを定義することで、コンテキストのないオーバーロードの使用を無効にすることができる。

オーバーロードされた関数は、qOverload の助けを借りて解決できる。

注：この関数はスレッドセーフです。

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

この関数は connect() をオーバーロードする。

sender オブジェクトからこのオブジェクトのmethod にsignal を接続する。

connect(sender,signal,this,method,type) と同等。

接続するたびにシグナルが出力されるので、重複した接続は2つのシグナルを出力します。接続を切断するにはdisconnect() を使用します。

注意：この関数はスレッドセーフです。

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)

この関数は connect() をオーバーロードします。

sender オブジェクトのsignal からfunctor へ、context の特定のイベントループに配置される、指定されたtype の接続を作成し、接続へのハンドルを返します。

シグナルは、ヘッダでシグナルとして宣言された関数でなければなりません。スロット関数は、シグナルに接続できる関数やファンクタであれば何でもかまいません。スロット関数は、シグナルが少なくともスロット関数と同じ数の引数を持っていれば、与えられたシグナルに接続することができます。シグナルとスロットの対応する引数の型の間には暗黙の変換が存在しなければなりません。

例

void someFunction();
QPushButton *button = new QPushButton;
QObject::connect(button, &QPushButton::clicked, this, someFunction, Qt::QueuedConnection);

ラムダ式も使用できます：

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);

送信者またはコンテキストが破棄されると、接続は自動的に切断されます。ただし、シグナルが発信されたときに、ファンクタ内で使用されているオブジェクトがまだ生きているように注意する必要があります。

オーバーロードされた関数はqOverload で解決できます。

注意：この関数はスレッドセーフです。

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

この関数は connect() をオーバーロードします。

sender オブジェクトのsignal からreceiver オブジェクトのmethod へ、与えられたtype の接続を作成します。後で接続を切断するために使用できる、接続へのハンドルを返します。

シグナルは、ヘッダーでシグナルとして宣言された関数でなければならない。スロット関数は、シグナルに接続できる任意のメンバ関数である。シグナルが少なくともスロットと同じ数の引数を持ち、シグナルとスロットの対応する引数の型の間に暗黙の変換がある場合、スロットは与えられたシグナルに接続することができます。

例

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

この例では、ラベルが常に現在行の編集テキストを表示するようにします。

シグナルは多くのスロットやシグナルに接続することができます。多くのシグナルを1つのスロットに接続することができます。

シグナルが複数のスロットに接続されている場合、シグナルが発信されると、接続された順序と同じ順序でスロットがアクティブになります。

この関数は、シグナルとスロットの接続に成功すると、コネクションのハンドルを返します。例えば、QObject がsignal の存在を確認できない場合（それがシグナルとして宣言されていない場合）、接続を作成できない場合、接続ハンドルは無効になります。QMetaObject::Connection が有効かどうかは、それを bool にキャストすることで確認できます。

デフォルトでは、接続が行われるたびにシグナルが発行され、重複接続の場合は2つのシグナルが発行されます。これらの接続をすべて切断するには、disconnect() を 1 回呼び出します。Qt::UniqueConnection type を渡すと、重複接続でない場合のみ接続が行われる。すでに重複（同じオブジェクトのまったく同じスロットにまったく同じシグナル） がある場合、接続は失敗し、connectは無効なQMetaObject::Connection を返します。

オプションのtype パラメータは、確立する接続のタイプを記述します。特に、特定のシグナルを即座にスロットに配信するか、後で配信するためにキューに入れるかを決定します。シグナルがキューイングされる場合、Qtは裏で引数をコピーしてイベントに格納する必要があるため、パラメータはQtのメタオブジェクトシステムが知っている型でなければなりません。キューイングされた接続を使おうとしてエラーメッセージが表示された場合は、次のようにしてください。

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

で引数の型を宣言してください。Q_DECLARE_METATYPE

オーバーロードされた関数はqOverload を使って解決できます。

注意：この関数はスレッドセーフです。

文字列ベース接続とファンクタベース接続の違い」も参照してください 。

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

この仮想関数は、このオブジェクトのsignal に何かが接続されると呼び出されます。

signal を特定のシグナルと比較したい場合は、以下のようにQMetaMethod::fromSignal() を使用することができる：

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

connect() およびdisconnectNotify()も参照の こと。

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

このイベント・ハンドラは、カスタム・イベントを受け取るためにサブクラスで再実装できます。カスタム・イベントは、QEvent::Type enumのQEvent::User 項目と少なくとも同じ大きさの型値を持つユーザー定義イベントで、通常はQEvent サブクラスです。イベントはevent パラメータで渡される。

event() およびQEventも参照のこと 。

[slot] void QObject::deleteLater()

このオブジェクトの削除をスケジュールします。

このオブジェクトは、制御がイベント・ループに戻ったときに削除されます。この関数が呼び出されたときにイベント・ループが実行されていない場合 (例えば、QCoreApplication::exec() の前にオブジェクトに対して deleteLater() が呼び出された場合)、イベント・ループが開始されると、オブジェクトは削除されます。メイン・イベント・ループが停止した後に deleteLater() が呼び出された場合、オブジェクトは削除されません。イベント・ループが実行されていないスレッドに存在するオブジェクトに対して deleteLater() が呼び出された場合、そのスレッドが終了するとオブジェクトは破棄されます。

オブジェクトを削除するには、deleteLater() が呼び出されたイベントループにコントロールが戻る必要があります。オブジェクトが削除されるためには、コントロールは deleteLater() が呼び出されたイベントループに戻らなければなりません。これは、ネストされた以前のイベントループがまだ実行されている間に削除されたオブジェクトには適用されません。

Qt がQCoreApplication::exec() やQEventLoop::exec() などでイベントディスパッチャを駆動していない状況では、遅延削除は自動的に処理されません。このシナリオで遅延削除を確実に行うには、以下の回避策を使用することができます：

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

注意：この関数はスレッドセーフである。

destroyed() およびQPointerも参照のこと 。

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

このシグナルは、QPointer のインスタンスが通知された後、オブジェクトobj が破棄される直前に発行され、ブロックすることはできません。

オブジェクトの子オブジェクトはすべて、このシグナルが発せられた直後に破棄される。

deleteLater() およびQPointerも参照のこと 。

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

接続を切断する。

connection が無効であるか、すでに切断されている場合は、何もせずに false を返します。

connect()も参照 。

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

オブジェクトsender 内のsignal を、オブジェクトreceiver 内のmethod から切断します。接続が正常に切断された場合はtrue を返し、そうでない場合はfalse を返す。

この関数は、disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method) と同じ可能性を提供しますが、QMetaMethod を使用して、切断されるシグナルとメソッドを表します。

さらに、この関数は、以下の場合にfalseを返し、シグナルもスロットも切断されません：

1. signal が送信者クラスまたはその親クラスのメンバでない場合。
2. method は、受信者クラスまたはその親クラスのメンバではありません。
3. signal インスタンスがシグナルでない。

ミスマッチを避けるには、connect （）によって返された接続ハンドルを保存し、disconnect （）の呼び出しでそれを使用します。

QMetaMethod()は、"任意のシグナル "または "受信オブジェクトの任意のスロット "という意 味で、ワイルドカードとして使用できます。同じように、nullptr は、「任意の受信オブジェクト」という意味で、receiver に使用することができます。この場合、メソッドもQMetaMethod()でなければならない。sender パラメータは決してnullptr 。

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)

オブジェクトsender 内のsignal を、オブジェクトreceiver 内のmethod から切断する。接続が正常に切断された場合はtrue を返し、そうでない場合はfalse を返す。

シグナル・スロットの接続は、関係するオブジェクトのいずれかが破棄されると削除される。

disconnect()は通常、以下の例のように3つの方法で使用されます。

1. オブジェクトのシグナルに接続されているすべてを切断する：

   disconnect(myObject, nullptr, nullptr, nullptr);

   静的でないオーバーロード関数

   myObject->disconnect();

2. 特定のシグナルに接続されているものすべてを切断する：

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

   非静的オーバーロード関数と同等

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

3. 特定のレシーバーを切断する：

   disconnect(myObject, nullptr, myReceiver, nullptr);

   非静的オーバーロード関数と同等

   myObject->disconnect(myReceiver);

不一致を避けるには、connect （） が返す接続ハンドルを保存し、disconnect （）の呼び出しでそれを使用する。

nullptr はワイルドカードとして使用でき、それぞれ「任意のシグナル」、 「任意の受信オブジェクト」、「受信オブジェクトの任意のスロット」を意味する。

sender がnullptr になることはない(1回の呼び出しで、複数のオブジェクトからシグナ ルを切断することはできない)。

signal がnullptr の場合、receiver とmethod のシグナルを切断する。そうでない場合は、指定されたシグナルのみが切断される。

receiver がnullptr の場合、signal に接続されているすべての接続を切断する。そうでない場合、receiver 以外のオブジェクトのスロットは切断されない。

method がnullptr の場合、receiver に接続されているものはすべて切断されます。そうでない場合、method という名前のスロットだけが切断され、それ以外のスロットはそのまま残されます。receiver が抜けている場合、method はnullptr でなければならないので、すべてのオブジェクトで特定の名前のスロットを切断することはできない。

注意：この関数はスレッドセーフです。

connect()も参照してください 。

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

この関数は disconnect() をオーバーロードします。

このオブジェクトのすべてのシグナルをreceiver のmethod から切断します。

ミスマッチを避けるため、connect （） が返す接続ハンドルを保存し、disconnect （）の呼び出しで使用する。

シグナル・スロット接続は、関係するオブジェクトのいずれかが破棄されると削除される。

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

この関数は disconnect() をオーバーロードしている。

receiver のmethod からsignal を切断する。

ミスマッチを避けるため、connect （） が返す接続ハンドルを保存し、disconnect （）の呼び出しで使用する。

シグナル・スロット接続は、関係するオブジェクトのいずれかが破棄されると削除されます。

注：この関数はスレッドセーフである。

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

この関数は disconnect() をオーバーロードする。

オブジェクトsender 内のsignal をオブジェクトreceiver 内のmethod から切断する。接続が正常に切断された場合はtrue を返し、そうでない場合はfalse を返します。

シグナル・スロット接続は、関係するオブジェクトのいずれかが破棄されると削除されます。

disconnect()は、以下の例が示すように、通常3つの方法で使用されます。

1. オブジェクトのシグナルに接続されているすべてを切断する：

   disconnect(myObject, nullptr, nullptr, nullptr);

2. 特定のシグナルに接続されているものすべてを切断する：

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

3. 特定のレシーバーを切断する：

   disconnect(myObject, nullptr, myReceiver, nullptr);

4. 特定の信号から特定のスロットへの接続を切断する：

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

nullptr は、それぞれ「任意のシグナル」、「任意の受信オブジェクト」、「受信オブジェクトの任意のスロット」を意味するワイルドカードとして使用することができる。

sender がnullptr になることはない(1回の呼び出しで、複数のオブジェクトからシグナ ルを切断することはできない)。

signal がnullptr の場合、receiver とmethod のシグナルを切断する。そうでない場合は、指定されたシグナルのみが切断される。

receiver がnullptr の場合、signal に接続されているすべての接続が切断される。そうでない場合、指定されたレシーバのスロットのみが切断される。receiver が NULL でない disconnect() は、receiver をコンテキスト・オブジェクトとして接続されていたスロット関数も切断する。

method がnullptr である場合、receiver に接続されているものはすべて切断されます。そうでない場合、method という名前のスロットだけが切断され、他のスロットはすべて放置されます。receiver が抜けている場合、method はnullptr でなければならないので、すべてのオブジェクトで特定の名前のスロットを切断することはできない。

注意：この関数はスレッドセーフである。

connect()も参照のこと 。

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

この仮想関数は、このオブジェクトのsignal から何かが切断されたときに呼び出される。

signal と特定のシグナルを比較する例については、connectNotify() を参照。

このオブジェクトからすべてのシグナルが切断された場合（例えば、disconnect() のシグナル引数がnullptr だった場合）、 disconnectNotify() は一度だけ呼び出され、signal は無効なQMetaMethod となる (QMetaMethod::isValid() はfalse を返す )。

disconnect() およびconnectNotify()も参照の こと。

void QObject::dumpObjectInfo() const

このオブジェクトのシグナル接続などの情報をデバッグ出力にダンプします。

dumpObjectTree()も参照してください 。

void QObject::dumpObjectTree() const

子オブジェクトのツリーをデバッグ出力にダンプします。

dumpObjectInfo()も参照して ください。

QList<QByteArray> QObject::dynamicPropertyNames() const

setProperty() を使用してオブジェクトに動的に追加されたすべてのプロパティの名前を返します。

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

この仮想関数は、オブジェクトへのイベントを受け取り、イベントe が認識され、処理された場合、true を返す必要があります。

event() 関数は、オブジェクトの振る舞いをカスタマイズするために再実装することができます。

処理しなかったイベントについては、必ず親イベント・クラスの実装を呼び出してください。

例

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);
    }
};

installEventFilter()、timerEvent()、QCoreApplication::sendEvent()、QCoreApplication::postEvent()も参照 。

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

このオブジェクトがwatched オブジェクトのイベント・フィルターとしてインストールされている場合、イベントをフィルターします。

この関数の再実装で、event をフィルタリングしたい場合、つまり、それ以上処理されないようにしたい場合は、true を返し、そうでない場合は false を返します。

例

class 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 *keyEvent = static_cast<QKeyEvent*>(event);
            qDebug() << "Ate key press" << keyEvent->key();
            return true;
        } else {
            return false;
        }
    } else {
        // pass the event on to the parent class
        return QMainWindow::eventFilter(obj, event);
    }
}

例：上の例では、処理されなかったイベントは、ベースクラスの eventFilter() 関数に渡されます。

伝搬を防ぐために、QEvent::ShortcutOverride のようないくつかのイベントは、明示的に（accept() を呼び出すことで）受け入れなければなりません。

installEventFilter()も参照してください 。

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

このオブジェクトの子オブジェクトで、T型にキャストでき、name 、そのようなオブジェクトがない場合はnullptr を返します。引数name が NULL の場合、すべてのオブジェクトがマッチします。空で NULL ではないname は、objectName が空であるオブジェクトにのみマッチします。検索は、options で FindDirectChildrenOnly オプションが指定されていない限り、再帰的に実行されます。

検索にマッチする子が複数ある場合は、最も直接の祖先が返されます。最直属の先祖が複数ある場合は、children() の最初の子が返されます。その場合は、findChildren() を使用して、すべての子の完全なリストを取得する方がよいでしょう。

この例では、ボタンが親の直接の子でなくても、"button1" というparentWidget の子QPushButton を返します：

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

この例は、parentWidget の子QListWidget を返します：

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

この例は、parentWidget （その直接の親）の子QPushButton を返します。名前は"button1" です：

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

この例は、直接の親であるparentWidget の子QListWidget を返します：

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

findChildren()も参照してください 。

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

これはオーバーロードされた関数です。

T型にキャストできるこのオブジェクトの子オブジェクトを返すか、そのようなオブジェクトがない場合はnullptr を返します。options で FindDirectChildrenOnly オプションが指定されていない限り、検索は再帰的に実行されます。

検索にマッチする子が複数ある場合は、最も直接の祖先が返されます。最直属の先祖が複数ある場合は、children() の最初の子が返されます。その場合は、findChildren() を使用して、すべての子の完全なリストを取得する方がよいでしょう。

この関数は Qt 6.7 で導入されました。

findChildren()も参照してください 。

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

与えられたname を持つこのオブジェクトのすべての子オブジェクトで、T 型にキャストできるもの、またはそのようなオブジェクトがない場合は空のリストを返します。引数name が NULL の場合はすべてのオブジェクトがマッチし、空の場合はobjectName が空であるオブジェクトのみがマッチします。検索は、options で FindDirectChildrenOnly オプションが指定されていない限り、再帰的に実行されます。

次の例は、指定されたparentWidget の子QWidgetのリストをwidgetname という名前で検索する方法を示しています：

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

この例では、parentWidget の子であるすべてのQPushButtonを返します：

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

この例では、parentWidget の直接の子であるQPushButtonをすべて返します：

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

findChild()も参照してください 。

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

これはオーバーロードされた関数です。

T型にキャストできるこのオブジェクトのすべての子オブジェクト、またはそのようなオブジェクトがない場合は空のリストを返します。検索は、options が FindDirectChildrenOnly オプションを指定しない限り、再帰的に実行されます。

この関数は Qt 6.3 で導入されました。

findChild()も参照してください 。

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

この関数は findChildren() をオーバーロードします。

このオブジェクトの子オブジェクトのうち、T型にキャストでき、かつ、正規表現re にマッチする名前を持つオブジェクトを返します。options で FindDirectChildrenOnly オプションが指定されていない限り、検索は再帰的に実行されます。

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

このオブジェクトがclassName を継承するクラス、またはclassName を継承するQObject サブクラスのインスタンスである場合はtrue を返し、そうでない場合はfalse を返します。

クラスはそれ自身を継承するとみなされます。

例

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)

例: オブジェクトをキャストするために、そのオブジェクトが特定のクラスのインスタンスであるかどうかを判断する必要がある場合は、代わりにqobject_cast<Type *>(object) を使用することを検討してください。

metaObject() およびqobject_cast()も参照 。

void QObject::installEventFilter(QObject *filterObj)

このオブジェクトにイベント・フィルターfilterObj をインストールします。例えば

monitoredObj->installEventFilter(filterObj);

イベント・フィルターは、このオブジェクトに送られるすべてのイベントを受け取るオブジェクトです。フィルタは、イベントを停止するか、このオブジェクトに転送します。イベント・フィルターfilterObj は、そのeventFilter() 関数を通してイベントを受信します。eventFilter()関数は、イベントがフィルターされるべき（つまり停止されるべき）場合はtrueを返し、そうでない場合はfalseを返さなければならない。

1つのオブジェクトに複数のイベントフィルターがインストールされている場合、最後にインストールされたフィルターが最初に有効になります。

このオブジェクトにfilterObj がすでにインストールされている場合、この関数はそれを移動させ、あたかも最後にインストールされたかのように動作します。

以下は、監視対象オブジェクトのキー入力を食べるKeyPressEater クラスです：

class KeyPressEater : public QObject
{
    Q_OBJECT
    ...

protected:
    bool eventFilter(QObject *obj, QEvent *event) override;
};

bool KeyPressEater::eventFilter(QObject *obj, QEvent *event)
{
    if (event->type() == QEvent::KeyPress) {
        QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
        qDebug("Ate key press %d", keyEvent->key());
        return true;
    } else {
        // standard event processing
        return QObject::eventFilter(obj, event);
    }
}

そして、これを2つのウィジェットにインストールする方法を示します：

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

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

例えば、QShortcut クラスは、このテクニックを使ってショートカット・キーの押下を傍受します。

フィルタリングオブジェクトは、このオブジェクトと同じスレッドになければならないことに注意してください。filterObj が別のスレッドにある場合、この関数は何もしません。この関数を呼び出した後、filterObj またはこのオブジェクトのどちらかが別のスレッドに移動した場合、両方のオブジェクトが再び同じスレッド親和性を持つまで、イベント・フィルターは呼び出されません（削除されません）。

removeEventFilter()、eventFilter()、event()も参照 。

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

オブジェクトがQQuickItem の場合はtrue を返し、そうでない場合はfalse を返す。

この関数を呼び出すことは、inherits("QQuickItem") を呼び出すことと同じですが、より高速です。

この関数はQt 6.4で導入されました。

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

signal が少なくとも1つのレシーバに接続されていればtrue を返し、そうでなければfalse を返します。

signal はこのオブジェクトのシグナル・メンバでなければならず、そうでなければ動作は未定義です。

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

上記のコード・スニペットが示すように、この関数を使用することで、高価な初期化や、誰も聞いていないシグナルを発することを避けることができます。しかし、マルチスレッド・アプリケーションでは、この関数が返された後、シグナルが発せられる前に接続が変更される可能性があります。

bool QObject::isWidgetType() const

オブジェクトがウィジェットの場合はtrue を返し、そうでない場合はfalse を返します。

この関数を呼び出すことは、inherits("QWidget") を呼び出すことと同じですが、はるかに高速です。

bool QObject::isWindowType() const

オブジェクトがウィンドウの場合はtrue を返し、そうでない場合はfalse を返します。

この関数を呼び出すことは、inherits("QWindow") を呼び出すことと同じです。

void QObject::killTimer(int id)

タイマー識別子id を持つタイマーを終了させます。

タイマー識別子は、タイマー・イベントが開始されたときにstartTimer() によって返される。

timerEvent() およびstartTimer()も参照してください 。

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

これはオーバーロードされた関数です。

この関数は Qt 6.8 で導入されました。

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

このオブジェクトのメタオブジェクトへのポインタを返します。

メタオブジェクトには、QObject を継承するクラスに関する情報（クラス名、スーパークラス名、プロパティ、シグナル、スロットなど）が含まれます。Q_OBJECT マクロを含むQObject サブクラスはすべてメタオブジェクトを持ちます。

メタオブジェクトの情報は、シグナル/スロット接続メカニズムとプロパティ・システムで必要とされます。inherits()関数もメタオブジェクトを利用します。

実際のオブジェクト・インスタンスへのポインタがない場合でも、クラスのメタ・オブジェクトにアクセスしたい場合は、staticMetaObject 。

例

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

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

staticMetaObjectも参照してください 。

bool QObject::moveToThread(QThread *targetThread)

このオブジェクトとその子のスレッド親和性を変更し、成功するとtrue を返します。オブジェクトに親がある場合は移動できません。イベント処理はtargetThread で続行されます。

オブジェクトをメイン・スレッドに移動するには、QApplication::instance() を使用して現在のアプリケーションへのポインタを取得し、QApplication::thread() を使用してアプリケーションが存在するスレッドを取得します。例えば

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

targetThread がnullptr の場合、このオブジェクトとその子のイベント処理はすべて停止する。

オブジェクトのアクティブなタイマーはすべてリセットされることに注意してください。タイマーは、まず現在のスレッドで停止され、targetThread で（同じ間隔で）再開される。その結果、スレッド間でオブジェクトを常に移動させると、タイマーイベントが無期限に延期される可能性がある。

スレッド・アフィニティが変更される直前に、QEvent::ThreadChange イベントがこのオブジェクトに送られます。このイベントを処理することで、特別な処理を行うことができます。このオブジェクトにポストされる新しいイベントは、nullptr でない限り、targetThread で処理されることに注意してください。nullptr の場合、このオブジェクトやその子オブジェクトはどのスレッドにも関連付けられなくなるため、イベント処理を行うことはできません。

thread()も参照のこと 。

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

このシグナルは、オブジェクトの名前が変更された後に発行される。新しいオブジェクト名はobjectName として渡される。

QObject::objectNameも参照 。

QObject *QObject::parent() const

親オブジェクトへのポインタを返します。

setParent() およびchildren()も参照して ください。

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

オブジェクトのname プロパティの値を返します。

そのようなプロパティが存在しない場合、返されるバリアントは無効です。

利用可能なすべてのプロパティに関する情報は、metaObject() およびdynamicPropertyNames() を通して提供されます。

setProperty()、QVariant::isValid()、metaObject()、dynamicPropertyNames()も参照して ください。

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

signal に接続されている受信機の数を返す。

スロットもシグナルもシグナルのレシーバーとして使用でき、同じ接続を何度も行うことができるため、レシーバーの数は、このシグナルから行われた接続の数と同じになります。

この関数を呼び出す際には、SIGNAL() マクロを使用して特定のシグナルを渡すことができる：

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

isSignalConnected()も参照 。

void QObject::removeEventFilter(QObject *obj)

このオブジェクトからイベント・フィルター・オブジェクトobj を削除します。そのようなイベント・フィルターがインストールされていない場合、リクエストは無視されます。

このオブジェクトのすべてのイベント・フィルターは、このオブジェクトが破棄されるときに自動的に削除されます。

イベント・フィルタの起動中（つまりeventFilter() 関数から）であっても、イベント・フィルタを削除することは常に安全です。

installEventFilter()、eventFilter()、event()も参照 。

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

シグナルによって活性化されたスロットで呼び出された場合は、シグナルを送信したオブジェク トへのポインタを返します。そうでない場合は、nullptr を返します。このポインタは、このオブジェクトのスレッドコンテキストからこの関数を呼び出したスロットの実行中にのみ有効です。

この関数が返すポインタは、送信者が破棄されたり、スロットが送信者のシグナルから切断されたりすると無効になります。

senderSignalIndex()も参照してください 。

[protected] int QObject::senderSignalIndex() const

現在実行中のスロットを呼び出したシグナルのメタメソッドインデックスを返します。このシグ ナルは、sender() によって返されたクラスのメンバです。シグナルによって起動されたスロットの外部で呼び出された場合は、-1 が返されます。

デフォルトのパラメータを持つシグナルの場合、この関数は、connect() で使用されたパラメータに関係なく、常にすべてのパラメータを持つインデックスを返します。例えば、シグナルdestroyed(QObject *obj = \nullptr) は2つの異なるインデックス（パラメータ付きとパラメータなし）を持ちますが、この関数は常にパラメータ付きのインデックスを返します。これは、異なるパラメータを持つシグナルをオーバーロードする場合には適用されません。

sender()、QMetaObject::indexOfSignal()、QMetaObject::method()も参照 。

void QObject::setObjectName(const QString &name)

オブジェクトの名前をname に設定します。

objectName()も参照して ください。

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

これはオーバーロードされた関数です。

この関数は Qt 6.4 で導入されました。

void QObject::setParent(QObject *parent)

オブジェクトをparent の子にします。

parent() およびchildren()も参照してください 。

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

オブジェクトのname プロパティの値をvalue に設定します。

そのプロパティがQ_PROPERTY を使用してクラスで定義されている場合は、成功時に true が返され、そうでない場合は false が返されます。プロパティがQ_PROPERTY を使用して定義されておらず、したがってメタ・オブジェクトにリストされていない場合は、動的プロパティとして追加され、false が返されます。

利用可能なすべてのプロパティに関する情報は、metaObject() とdynamicPropertyNames() を通して提供されます。

ダイナミック・プロパティは、property() を使用して再度クエリでき、プロパティ値を無効なQVariant に設定することで削除できます。ダイナミック・プロパティの値を変更すると、QDynamicPropertyChangeEvent がオブジェクトに送信されます。

注意："_q_"で始まるダイナミック・プロパティは、内部用に予約されています。

property()、metaObject()、dynamicPropertyNames()、QMetaProperty::write()も参照 。

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

この関数は setProperty をオーバーロードします。

この関数は Qt 6.6 で導入されました。

[noexcept] bool QObject::signalsBlocked() const

シグナルがブロックされている場合はtrue を返し、そうでない場合はfalse を返します。

デフォルトではシグナルはブロックされません。

blockSignals() およびQSignalBlockerも参照してください 。

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

これはオーバーロードされた関数で、timerType 型のタイマーを開始し、interval ミリ秒のタイムアウトを設定します。これは呼び出しと同じである：

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

timerEvent()、killTimer()、QChronoTimer 、およびQBasicTimerも参照 。

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

これはオーバーロードされた関数である。

タイマーを開始し、タイマー識別子を返すか、タイマーを開始できなかった場合はゼロを返します。

killTimer （）が呼び出されるまで、interval 毎にタイマー・イベントが発生する。interval がstd::chrono::duration::zero() と等しい場合、処理すべきウィンドウ・システム・イベントがなくなるたびに、 タイマー・イベントが1回発生する。

仮想timerEvent （）関数は、タイマー・イベントが発生すると、QTimerEvent イベント・パラメーター・クラスで呼び出されます。タイマー・イベントを取得するには、この関数を再実装します。

複数のタイマーが動作している場合、QTimerEvent::id() メソッドを使用して、どのタイマーが起動されたかを調べることができます。

例

class MyObject : public QObject
{
    Q_OBJECT

public:
    MyObject(QObject *parent = nullptr);

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 *event)
{
    qDebug() << "Timer ID:" << event->id();
}

タイマーの精度は、基盤となるオペレーティング・システムとハードウェアに依存することに注意してください。

引数timerType 、タイマーの精度をカスタマイズできる。タイマーの種類についてはQt::TimerType を参照のこと。ほとんどのプラットフォームは20ミリ秒の精度をサポートしています。Qt は、要求された数のタイマー・イベントを提供できない場合、いくつかのイベントを静かに破棄します。

QTimer とQChronoTimer クラスは、イベントの代わりにシングルショットタイマーとタイマーシグナルを使用した高レベルプログラミングインターフェイスを提供します。また、QChronoTimer よりも軽量ですが、タイマー ID を直接使用するよりも扱いにくいQBasicTimer クラスもあります。

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

timerEvent()、killTimer()、QChronoTimer 、QBasicTimerも参照 。

QThread *QObject::thread() const

オブジェクトが存在するスレッドを返します。

moveToThread() も参照 。

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

このイベント・ハンドラをサブクラスで再実装して、オブジェクトのタイマー・イベントを受け取ることができます。

QChronoTimer は、タイマー機能へのより高いレベルのインタフェースと、タイマーに関するより一般的な情報を提供します。タイマー・イベントは パラメータで渡されます。event

startTimer()、killTimer()、event()も参照 。

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

disambiguation の文字列と、複数形を含む文字列の場合はn の値に基づいて、sourceText の翻訳バージョンを返します。適切な翻訳文字列がない場合は、QString::fromUtf8(sourceText) を返します。

例

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

例: 同じsourceText が同じコンテキスト内で異なる役割で使用される場合、追加の識別文字列をdisambiguation ( デフォルトではnullptr ) で渡すことができる。

例

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

Qt の翻訳メカニズム全般に関する詳細な説明については「翻訳用ソースコードの記述」を、曖昧性解消に関する情報については「同一テキストの曖昧性解消」を参照してください。

QCoreApplication::translate() およびInternationalization with Qtも参照してください 。