/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the documentation of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, 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.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
/*!
\page metaobjects.html
\title Meta-Object System
\brief An overview of Qt's meta-object system and introspection capabilities.
\keyword meta-object
Qt's meta-object system provides the signals and slots mechanism for
inter-object communication, run-time type information, and the dynamic
property system.
The meta-object system is based on three things:
\list 1
\o The \l QObject class provides a base class for objects that can
take advantage of the meta-object system.
\o The Q_OBJECT macro inside the private section of the class
declaration is used to enable meta-object features, such as
dynamic properties, signals, and slots.
\o The \l{moc}{Meta-Object Compiler} (\c moc) supplies each
QObject subclass with the necessary code to implement
meta-object features.
\endlist
The \c moc tool reads a C++ source file. If it finds one or more
class declarations that contain the Q_OBJECT macro, it
produces another C++ source file which contains the meta-object
code for each of those classes. This generated source file is
either \c{#include}'d into the class's source file or, more
usually, compiled and linked with the class's implementation.
In addition to providing the \l{signals and slots} mechanism for
communication between objects (the main reason for introducing
the system), the meta-object code provides the following
additional features:
\list
\o QObject::metaObject() returns the associated
\l{QMetaObject}{meta-object} for the class.
\o QMetaObject::className() returns the class name as a
string at run-time, without requiring native run-time type information
(RTTI) support through the C++ compiler.
\o QObject::inherits() function returns whether an object is an
instance of a class that inherits a specified class within the
QObject inheritance tree.
\o QObject::tr() and QObject::trUtf8() translate strings for
\l{Internationalization with Qt}{internationalization}.
\o QObject::setProperty() and QObject::property()
dynamically set and get properties by name.
\o QMetaObject::newInstance() constructs a new instance of the class.
\endlist
\target qobjectcast
It is also possible to perform dynamic casts using qobject_cast()
on QObject classes. The qobject_cast() function behaves similarly
to the standard C++ \c dynamic_cast(), with the advantages
that it doesn't require RTTI support and it works across dynamic
library boundaries. It attempts to cast its argument to the pointer
type specified in angle-brackets, returning a non-zero pointer if the
object is of the correct type (determined at run-time), or 0
if the object's type is incompatible.
For example, let's assume \c MyWidget inherits from QWidget and
is declared with the Q_OBJECT macro:
\snippet doc/src/snippets/qtcast/qtcast.cpp 0
The \c obj variable, of type \c{QObject *}, actually refers to a
\c MyWidget object, so we can cast it appropriately:
\snippet doc/src/snippets/qtcast/qtcast.cpp 1
The cast from QObject to QWidget is successful, because the
object is actually a \c MyWidget, which is a subclass of QWidget.
Since we know that \c obj is a \c MyWidget, we can also cast it to
\c{MyWidget *}:
\snippet doc/src/snippets/qtcast/qtcast.cpp 2
The cast to \c MyWidget is successful because qobject_cast()
makes no distinction between built-in Qt types and custom types.
\snippet doc/src/snippets/qtcast/qtcast.cpp 3
\snippet doc/src/snippets/qtcast/qtcast.cpp 4
The cast to QLabel, on the other hand, fails. The pointer is then
set to 0. This makes it possible to handle objects of different
types differently at run-time, based on the type:
\snippet doc/src/snippets/qtcast/qtcast.cpp 5
\snippet doc/src/snippets/qtcast/qtcast.cpp 6
While it is possible to use QObject as a base class without the
Q_OBJECT macro and without meta-object code, neither signals
and slots nor the other features described here will be available
if the Q_OBJECT macro is not used. From the meta-object
system's point of view, a QObject subclass without meta code is
equivalent to its closest ancestor with meta-object code. This
means for example, that QMetaObject::className() will not return
the actual name of your class, but the class name of this
ancestor.
Therefore, we strongly recommend that all subclasses of QObject
use the Q_OBJECT macro regardless of whether or not they
actually use signals, slots, and properties.
\sa QMetaObject, {Qt's Property System}, {Signals and Slots}
*/