/****************************************************************************

**

** 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 moc.html

    \title Using the Meta-Object Compiler (moc)

    \ingroup qttools

    \keyword moc

    The Meta-Object Compiler, \c moc, is the program that handles

    \l{Meta-Object System}{Qt's C++ extensions}.

    The \c moc tool reads a C++ header file. If it finds one or more

    class declarations that contain the Q_OBJECT macro, it

    produces a C++ source file containing the meta-object code for

    those classes. Among other things, meta-object code is required

    for the signals and slots mechanism, the run-time type information,

    and the dynamic property system.

    The C++ source file generated by \c moc must be compiled and

    linked with the implementation of the class.

    If you use \l qmake to create your makefiles, build rules will be

    included that call the moc when required, so you will not need to

    use the moc directly. For more background information on \c moc,

    see \l{Why Doesn't Qt Use Templates for Signals and Slots?}

    \section1 Usage

    \c moc is typically used with an input file containing class

    declarations like this:

    \snippet doc/src/snippets/moc/myclass1.h 0

    In addition to the signals and slots shown above, \c moc also

    implements object properties as in the next example. The

    Q_PROPERTY() macro declares an object property, while

    Q_ENUMS() declares a list of enumeration types within the class

    to be usable inside the \l{Qt's Property System}{property

    system}.

    In the following example, we declare a property of the

    enumeration type \c Priority that is also called \c priority and

    has a get function \c priority() and a set function \c

    setPriority().

    \snippet doc/src/snippets/moc/myclass2.h 0

    The Q_FLAGS() macro declares enums that are to be used

    as flags, i.e. OR'd together. Another macro, Q_CLASSINFO(),

    allows you to attach additional name/value pairs to the class's

    meta-object:

    \snippet doc/src/snippets/moc/myclass3.h 0

    The output produced by \c moc must be compiled and linked, just

    like the other C++ code in your program; otherwise, the build

    will fail in the final link phase. If you use \c qmake, this is

    done automatically. Whenever \c qmake is run, it parses the

    project's header files and generates make rules to invoke \c moc

    for those files that contain a Q_OBJECT macro.

    If the class declaration is found in the file \c myclass.h, the

    moc output should be put in a file called \c moc_myclass.cpp.

    This file should then be compiled as usual, resulting in an

    object file, e.g., \c moc_myclass.obj on Windows. This object

    should then be included in the list of object files that are

    linked together in the final building phase of the program.

    \section1 Writing Make Rules for Invoking \c moc

    For anything but the simplest test programs, it is recommended

    that you automate running the \c{moc}. By adding some rules to

    your program's makefile, \c make can take care of running moc

    when necessary and handling the moc output.

    We recommend using the \l qmake makefile generation tool for

    building your makefiles. This tool generates a makefile that does

    all the necessary \c moc handling.

    If you want to create your makefiles yourself, here are some tips

    on how to include moc handling.

    For Q_OBJECT class declarations in header files, here is a

    useful makefile rule if you only use GNU make:

    \snippet doc/src/snippets/code/doc_src_moc.qdoc 0

    If you want to write portably, you can use individual rules of

    the following form:

    \snippet doc/src/snippets/code/doc_src_moc.qdoc 1

    You must also remember to add \c moc_foo.cpp to your \c SOURCES

    (substitute your favorite name) variable and \c moc_foo.o or \c

    moc_foo.obj to your \c OBJECTS variable.

    Both examples assume that \c $(DEFINES) and \c $(INCPATH) expand

    to the define and include path options that are passed to the C++

    compiler. These are required by \c moc to preprocess the source

    files.

    While we prefer to name our C++ source files \c .cpp, you can use

    any other extension, such as \c .C, \c .cc, \c .CC, \c .cxx, and

    \c .c++, if you prefer.

    For Q_OBJECT class declarations in implementation (\c .cpp)

    files, we suggest a makefile rule like this:

    \snippet doc/src/snippets/code/doc_src_moc.qdoc 2

    This guarantees that make will run the moc before it compiles

    \c foo.cpp. You can then put

    \snippet doc/src/snippets/code/doc_src_moc.qdoc 3

    at the end of \c foo.cpp, where all the classes declared in that

    file are fully known.

    \section1 Command-Line Options

    Here are the command-line options supported by the moc:

    \table

    \header \o Option \o Description

    \row

    \o \c{-o<file>}

    \o Write output to \c <file> rather than to standard output.

    \row

    \o \c{-f[<file>]}

    \o Force the generation of an \c #include statement in the

    output. This is the default for header files whose extension

    starts with \c H or \c h. This option is useful if you have

    header files that do not follow the standard naming conventions.

    The \c <file> part is optional.

    \row

    \o \c -i

    \o Do not generate an \c #include statement in the output.

    This may be used to run the moc on on a C++ file containing one or

    more class declarations. You should then \c #include the meta-object

    code in the \c .cpp file.

    \row

    \o \c -nw

    \o Do not generate any warnings. (Not recommended.)

    \row

    \o \c {-p<path>}

    \o Makes the moc prepend \c {<path>/} to the file name in the

    generated \c #include statement.

    \row

    \o \c {-I<dir>}

    \o Add dir to the include path for header files.

    \row

    \o \c{-E}

    \o Preprocess only; do not generate meta-object code.

    \row

    \o \c {-D<macro>[=<def>]}

    \o Define macro, with optional definition.

    \row

    \o \c{-U<macro>}

    \o Undefine macro.

    \row

    \o \c{@<file>}

    \o Read additional command-line options from \c{<file>}.

    Each line of the file is treated as a single option. Empty lines

    are ignored. Note that this option is not supported within the

    options file itself (i.e. an options file can't "include" another

    file).

    \row

    \o \c{-h}

    \o Display the usage and the list of options.

    \row

    \o \c {-v}

    \o Display \c{moc}'s version number.

    \row

    \o \c{-Fdir}

    \o Mac OS X. Add the framework directory \c{dir} to the head of

       the list of directories to be searched for header files. These

       directories are interleaved with those specified by -I options

       and are scanned in a left-to-right order (see the manpage for

       gcc). Normally, use -F /Library/Frameworks/

    \endtable

    You can explicitly tell the moc not to parse parts of a header

    file. \c moc defines the preprocessor symbol \c Q_MOC_RUN. Any

    code surrounded by

    \snippet doc/src/snippets/code/doc_src_moc.qdoc 4

    is skipped by the \c moc.

    \section1 Diagnostics

    \c moc will warn you about a number of dangerous or illegal

    constructs in the Q_OBJECT class declarations.

    If you get linkage errors in the final building phase of your

    program, saying that \c YourClass::className() is undefined or

    that \c YourClass lacks a vtable, something has been done wrong.

    Most often, you have forgotten to compile or \c #include the

    moc-generated C++ code, or (in the former case) include that

    object file in the link command. If you use \c qmake, try

    rerunning it to update your makefile. This should do the trick.

    \section1 Limitations

    \c moc does not handle all of C++. The main problem is that class

    templates cannot have signals or slots. Here is an example:

    \snippet doc/src/snippets/code/doc_src_moc.qdoc 5

    Another limitation is that moc does not expand macros, so you

    for example cannot use a macro to declare a signal/slot

    or use one to define a base class for a QObject.

    Less importantly, the following constructs are illegal. All of

    them have alternatives which we think are usually better, so

    removing these limitations is not a high priority for us.

    \section2 Multiple Inheritance Requires QObject to Be First

    If you are using multiple inheritance, \c moc assumes that the

    first inherited class is a subclass of QObject. Also, be sure

    that only the first inherited class is a QObject.

    \snippet doc/src/snippets/code/doc_src_moc.qdoc 6

    Virtual inheritance with QObject is \e not supported.

    \section2 Function Pointers Cannot Be Signal or Slot Parameters

    In most cases where you would consider using function pointers as

    signal or slot parameters, we think inheritance is a better

    alternative. Here is an example of illegal syntax:

    \snippet doc/src/snippets/code/doc_src_moc.qdoc 7

    You can work around this restriction like this:

    \snippet doc/src/snippets/code/doc_src_moc.qdoc 8

    It may sometimes be even better to replace the function pointer

    with inheritance and virtual functions.

    \section2 Enums and Typedefs Must Be Fully Qualified for Signal and Slot Parameters

    When checking the signatures of its arguments, QObject::connect()

    compares the data types literally. Thus,

    \l{Qt::Alignment}{Alignment} and \l{Qt::Alignment} are treated as

    two distinct types. To work around this limitation, make sure to

    fully qualify the data types when declaring signals and slots,

    and when establishing connections. For example:

    \snippet doc/src/snippets/code/doc_src_moc.qdoc 9

    \section2 Type Macros Cannot Be Used for Signal and Slot Parameters

    Since \c moc doesn't expand \c{#define}s, type macros that take

    an argument will not work in signals and slots. Here is an

    illegal example:

    \snippet doc/src/snippets/code/doc_src_moc.qdoc 10

    A macro without parameters will work.

    \section2 Nested Classes Cannot Have Signals or Slots

    Here's an example of the offending construct:

    \snippet doc/src/snippets/code/doc_src_moc.qdoc 11

    \section2 Signal/Slot return types cannot be references

    Signals and slots can have return types, but signals or slots returning references

    will be treated as returning void.

    \section2 Only Signals and Slots May Appear in the \c signals and \c slots Sections of a Class

    \c moc will complain if you try to put other constructs in the \c

    signals or \c slots sections of a class than signals and slots.

    \sa {Meta-Object System}, {Signals and Slots}, {Qt's Property System}

*/