| Classes - Annotated - Tree - Functions - Home - Structure

# qmetaobject.h

This is the verbatim text of the qmetaobject.h include file. It is provided only for illustration; the copyright remains with Trolltech.

    /****************************************************************************
    ** $Id: qt/src/kernel/qmetaobject.h   2.3.2   edited 2001-01-26 $
    **
    ** Definition of QMetaObject class
    **
    ** Created : 930419
    **
    ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
    **
    ** This file is part of the kernel module of the Qt GUI Toolkit.
    **
    ** This file may be distributed under the terms of the Q Public License
    ** as defined by Trolltech AS of Norway and appearing in the file
    ** LICENSE.QPL included in the packaging of this file.
    **
    ** This file may be distributed and/or modified under the terms of the
    ** GNU General Public License version 2 as published by the Free Software
    ** Foundation and appearing in the file LICENSE.GPL included in the
    ** packaging of this file.
    **
    ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
    ** licenses may use this file in accordance with the Qt Commercial License
    ** Agreement provided with the Software.
    **
    ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
    ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
    **
    ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
    **   information about Qt Commercial License Agreements.
    ** See http://www.trolltech.com/qpl/ for QPL licensing information.
    ** See http://www.trolltech.com/gpl/ for GPL licensing information.
    **
    ** Contact info@trolltech.com if any conditions of this licensing are
    ** not clear to you.
    **
    **********************************************************************/

    #ifndef QMETAOBJECT_H
    #define QMETAOBJECT_H

    #ifndef QT_H
    #include "qconnection.h"
    #include "qstrlist.h"
    #endif // QT_H

    class QObject;

    struct QMetaData                                // - member function meta data
    {                                               //   for signal and slots
        const char *name;                           // - member name
        QMember ptr;                                // - member pointer
        enum Access { Private, Protected, Public };
        /* ### add this in 3.0
           Access access;                           // - access permission
        */
    };

    struct QMetaEnum                                // enumerator meta data
    {                                               //  for properties
        QMetaEnum() { }
        ~QMetaEnum() { delete [] items; }
        const char *name;                           // - enumerator name
        uint count;                                 // - number of values
        struct Item                                 // - a name/value pair
        {
            const char *key;
            int value;
        };
        Item *items;                                // - the name/value pairs
        bool set;                                   // whether enum has to be treated as a set
    };

    #ifndef QT_NO_PROPERTIES
    class Q_EXPORT QMetaProperty                    // property meta data
    {
    public:
        QMetaProperty();
        ~QMetaProperty();

        const char  *type() const { return t; }     // type of the property
        const char* name() const { return n; }      // name of the property

        bool writable() const;
        bool writeable() const;                     // ### remove in 3.0
        bool isValid() const;

        bool isSetType() const;
        bool isEnumType() const;
        QStrList enumKeys() const;                  // enumeration names

        int keyToValue( const char* key ) const;    // enum and set conversion functions
        const char* valueToKey( int value ) const;
        int keysToValue( const QStrList& keys ) const;
        QStrList valueToKeys( int value ) const;

        bool stored( QObject* ) const;
        bool designable() const;

        const char* t;
        const char* n;
        QMember     get;                            // get-function or 0 ( 0 indicates an error )
        QMember     set;                            // set-function or 0
        QMember     store;                          // store-function or 0
        QMember     reset;                          // reset-function or 0
        QMetaEnum   *enumData;                      // a pointer to the enum specification or 0

        enum Specification  { Unspecified, Class, Reference, Pointer, ConstCharStar };
        Specification gspec;                        // specification of the get-function
        Specification sspec;                        // specification of the set-function

        enum Flags  {
            UnresolvedEnum       = 0x00000001,
            UnresolvedSet        = 0x00000002,
            UnresolvedEnumOrSet  = 0x00000004,
            UnresolvedStored     = 0x00000008,
            UnresolvedDesignable = 0x00000010,
            NotDesignable        = 0x00000020,
            NotStored            = 0x00000040,
            StdSet               = 0x00000080
        };

        bool testFlags( uint f ) const;
        void setFlags( uint f );
        void clearFlags( uint f );

    private:
        uint flags;
    };
    #endif // QT_NO_PROPERTIES

    struct QClassInfo                               // class info meta data
    {
        const char* name;                           // - name of the info
        const char* value;                          // - value of the info
    };

    class QMetaObjectPrivate;

    class Q_EXPORT QMetaObject                      // meta object class
    {
    public:
        QMetaObject( const char *class_name, const char *superclass_name,
                     QMetaData *slot_data,  int n_slots,
                     QMetaData *signal_data, int n_signals );
        QMetaObject( const char *class_name, const char *superclass_name,
                     QMetaData *slot_data,  int n_slots,
                     QMetaData *signal_data, int n_signals,
    #ifndef QT_NO_PROPERTIES
                     QMetaProperty *prop_data, int n_props,
                     QMetaEnum *enum_data, int n_enums,
    #endif
                     QClassInfo *class_info, int n_info );

        virtual ~QMetaObject();

        const char  *className()            const { return classname; }
        const char  *superClassName()       const { return superclassname; }

        QMetaObject *superClass()           const { return superclass; }

        bool        inherits( const char* clname ) const;

        int         numSlots( bool super = FALSE ) const;
        int         numSignals( bool super = FALSE ) const;

        QMetaData   *slot( int index, bool super = FALSE ) const;
        QMetaData   *signal( int index, bool super = FALSE ) const;

        QMetaData   *slot( const char *, bool super = FALSE ) const;
        QMetaData   *signal( const char *, bool super = FALSE ) const;

        QStrList    slotNames( bool super = FALSE ) const;
        QStrList    signalNames( bool super = FALSE ) const;

        int         numClassInfo( bool super = FALSE ) const;
        QClassInfo  *classInfo( int index, bool super = FALSE ) const;
        const char  *classInfo( const char* name, bool super = FALSE ) const;

    #ifndef QT_NO_PROPERTIES
        const QMetaProperty *property( const char* name, bool super = FALSE ) const;
        QStrList            propertyNames( bool super = FALSE ) const;
        void                resolveProperty( QMetaProperty* prop );
    #endif

        // static wrappers around constructors, necessary to work around a
        // Windows-DLL limitation: objects can only be deleted within a
        // DLL if they were actually created within that DLL.
        static QMetaObject  *new_metaobject( const char *, const char *,
                                            QMetaData *, int,
                                            QMetaData *, int,
    #ifndef QT_NO_PROPERTIES
                                            QMetaProperty *prop_data, int n_props,
                                            QMetaEnum *enum_data, int n_enums,
    #endif
                                            QClassInfo * class_info, int n_info );
        static QMetaObject  *new_metaobject( const char *, const char *,
                                            QMetaData *, int,
                                            QMetaData *, int );
        static QMetaData            *new_metadata( int );
        static QMetaData::Access            *new_metaaccess( int ); // ### remove in 3.0
        void set_slot_access( QMetaData::Access* );                 // ### remove in 3.0
        QMetaData::Access slot_access(int index, bool super = FALSE ); // ### remove in 3.0
        static QMetaEnum            *new_metaenum( int );
        static QMetaEnum::Item      *new_metaenum_item( int );
    #ifndef QT_NO_PROPERTIES
        static QMetaProperty        *new_metaproperty( int );
    #endif
        static QClassInfo           *new_classinfo( int );

    private:
        QMemberDict         *init( QMetaData *, int );
        QMetaData           *mdata( int code, const char *, bool ) const;
        QMetaData           *mdata( int code, int index, bool super ) const;

        const char          *classname;                     // class name
        const char          *superclassname;                // super class name
        QMetaObject         *superclass;                    // super class meta object
        QMetaObjectPrivate  *d;                             // private data for...
        void                *reserved;                      // ...binary compatibility
        QMetaData           *slotData;                      // slot meta data
        QMemberDict         *slotDict;                      // slot dictionary
        QMetaData           *signalData;                    // signal meta data
        QMemberDict         *signalDict;                    // signal dictionary
        QMetaEnum           *enumerator( const char* name, bool super = FALSE ) const;

    private:        // Disabled copy constructor and operator=
    #if defined(Q_DISABLE_COPY)
        QMetaObject( const QMetaObject & );
        QMetaObject &operator=( const QMetaObject & );
    #endif
    };

    #ifndef QT_NO_PROPERTIES
    inline bool QMetaProperty::writable() const
    { return set != 0; }
    inline bool QMetaProperty::writeable() const
    { return set != 0; }
    inline bool QMetaProperty::testFlags( uint f ) const
    { return (flags & (uint)f) != (uint)0; }
    inline bool QMetaProperty::isValid() const
    { return get != 0 && !testFlags( UnresolvedEnum | UnresolvedDesignable | UnresolvedStored ) ; }
    inline bool QMetaProperty::isSetType() const
    { return ( enumData != 0 && enumData->set ); }
    inline bool QMetaProperty::isEnumType() const
    { return ( enumData != 0 ); }
    inline bool QMetaProperty::designable() const
    { return ( isValid() && set != 0 && !testFlags( NotDesignable | UnresolvedDesignable ) ); }
    inline void QMetaProperty::setFlags( uint f )
    { flags |= (uint)f; }
    inline void QMetaProperty::clearFlags( uint f )
    { flags &= ~(uint)f; }
    #endif

    // ### remove 3.0 (binary compatibility with Qt-2.0.2)
    class Q_EXPORT QMetaObjectInit {
    public:
        QMetaObjectInit(void(*)());
        static int init();
    };

    #endif // QMETAOBJECT_H