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

**

** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** GNU Lesser General Public License Usage

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

**

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU General

** Public License version 3.0 as published by the Free Software Foundation

** and appearing in the file LICENSE.GPL included in the packaging of this

** file. Please review the following information to ensure the GNU General

** Public License version 3.0 requirements will be met:

** http://www.gnu.org/copyleft/gpl.html.

**

** Other Usage

** Alternatively, this file may be used in accordance with the terms and

** conditions contained in a signed written agreement between you and Nokia.

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "qobject.h"

#include "qobject_p.h"

#include "qmetaobject_p.h"

#include "qabstracteventdispatcher.h"

#include "qcoreapplication.h"

#include "qcoreapplication_p.h"

#include "qvariant.h"

#include "qmetaobject.h"

#include <qregexp.h>

#include <qthread.h>

#include <private/qthread_p.h>

#include <qdebug.h>

#include <qhash.h>

#include <qpair.h>

#include <qvarlengtharray.h>

#include <qset.h>

#include <qsemaphore.h>

#include <qsharedpointer.h>

#include <private/qorderedmutexlocker_p.h>

#include <private/qmutexpool_p.h>

#include <new>

#include <ctype.h>

#include <limits.h>

QT_BEGIN_NAMESPACE

static int DIRECT_CONNECTION_ONLY = 0;

static int *queuedConnectionTypes(const QList<QByteArray> &typeNames)

{

    int *types = new int [typeNames.count() + 1];

    Q_CHECK_PTR(types);

    for (int i = 0; i < typeNames.count(); ++i) {

        const QByteArray typeName = typeNames.at(i);

        if (typeName.endsWith('*'))

            types[i] = QMetaType::VoidStar;

        else

            types[i] = QMetaType::type(typeName);

        if (!types[i]) {

            qWarning("QObject::connect: Cannot queue arguments of type '%s'\n"

                     "(Make sure '%s' is registered using qRegisterMetaType().)",

                     typeName.constData(), typeName.constData());

            delete [] types;

            return 0;

        }

    }

    types[typeNames.count()] = 0;

    return types;

}

static QBasicAtomicPointer<QMutexPool> signalSlotMutexes = Q_BASIC_ATOMIC_INITIALIZER(0);

static QBasicAtomicInt objectCount = Q_BASIC_ATOMIC_INITIALIZER(0);

/** \internal

 * mutex to be locked when accessing the connectionlists or the senders list

 */

static inline QMutex *signalSlotLock(const QObject *o)

{

    if (!signalSlotMutexes) {

        QMutexPool *mp = new QMutexPool;

        if (!signalSlotMutexes.testAndSetOrdered(0, mp)) {

            delete mp;

        }

    }

    return signalSlotMutexes->get(o);

}

extern "C" Q_CORE_EXPORT void qt_addObject(QObject *)

{

    objectCount.ref();

}

extern "C" Q_CORE_EXPORT void qt_removeObject(QObject *)

{

    if(!objectCount.deref()) {

        QMutexPool *old = signalSlotMutexes.fetchAndStoreAcquire(0);

        delete old;

    }

}

void (*QAbstractDeclarativeData::destroyed)(QAbstractDeclarativeData *, QObject *) = 0;

void (*QAbstractDeclarativeData::parentChanged)(QAbstractDeclarativeData *, QObject *, QObject *) = 0;

void (*QAbstractDeclarativeData::objectNameChanged)(QAbstractDeclarativeData *, QObject *) = 0;

QObjectData::~QObjectData() {}

QObjectPrivate::QObjectPrivate(int version)

    : threadData(0), connectionLists(0), senders(0), currentSender(0), currentChildBeingDeleted(0)

{

    if (version != QObjectPrivateVersion)

        qFatal("Cannot mix incompatible Qt library (version 0x%x) with this library (version 0x%x)",

                version, QObjectPrivateVersion);

    // QObjectData initialization

    q_ptr = 0;

    parent = 0;                                 // no parent yet. It is set by setParent()

    isWidget = false;                           // assume not a widget object

    pendTimer = false;                          // no timers yet

    blockSig = false;                           // not blocking signals

    wasDeleted = false;                         // double-delete catcher

    sendChildEvents = true;                     // if we should send ChildInsert and ChildRemove events to parent

    receiveChildEvents = true;

    postedEvents = 0;

    extraData = 0;

    connectedSignals[0] = connectedSignals[1] = 0;

    inThreadChangeEvent = false;

#ifdef QT_JAMBI_BUILD

    inEventHandler = false;

    deleteWatch = 0;

#endif

    metaObject = 0;

    hasGuards = false;

}

QObjectPrivate::~QObjectPrivate()

{

    if (pendTimer) {

        // unregister pending timers

        if (threadData && threadData->eventDispatcher)

            threadData->eventDispatcher->unregisterTimers(q_ptr);

    }

    if (postedEvents)

        QCoreApplication::removePostedEvents(q_ptr, 0);

    if (threadData)

        threadData->deref();

    delete static_cast<QAbstractDynamicMetaObject*>(metaObject);

#ifdef QT_JAMBI_BUILD

    if (deleteWatch)

        *deleteWatch = 1;

#endif

#ifndef QT_NO_USERDATA

    if (extraData)

        qDeleteAll(extraData->userData);

    delete extraData;

#endif

}

#ifdef QT_JAMBI_BUILD

int *QObjectPrivate::setDeleteWatch(QObjectPrivate *d, int *w) {

    int *old = d->deleteWatch;

    d->deleteWatch = w;

    return old;

}

void QObjectPrivate::resetDeleteWatch(QObjectPrivate *d, int *oldWatch, int deleteWatch) {

    if (!deleteWatch)

        d->deleteWatch = oldWatch;

    if (oldWatch)

        *oldWatch = deleteWatch;

}

#endif

#ifdef QT3_SUPPORT

void QObjectPrivate::sendPendingChildInsertedEvents()

{

    Q_Q(QObject);

    for (int i = 0; i < pendingChildInsertedEvents.size(); ++i) {

        QObject *c = pendingChildInsertedEvents.at(i).data();

        if (!c || c->parent() != q)

            continue;

        QChildEvent childEvent(QEvent::ChildInserted, c);

        QCoreApplication::sendEvent(q, &childEvent);

    }

    pendingChildInsertedEvents.clear();

}

#endif

/*!\internal

  For a given metaobject, compute the signal offset, and the method offset (including signals)

*/

static void computeOffsets(const QMetaObject *metaobject, int *signalOffset, int *methodOffset)

{

    *signalOffset = *methodOffset = 0;

    const QMetaObject *m = metaobject->d.superdata;

    while (m) {

        const QMetaObjectPrivate *d = QMetaObjectPrivate::get(m);

        *methodOffset += d->methodCount;

        *signalOffset += (d->revision >= 4) ? d->signalCount : d->methodCount;

        /*Before Qt 4.6 (revision 4), the signalCount information was not generated by moc.

           so for compatibility we consider all the method as slot for old moc output*/

        m = m->d.superdata;

    }

}

/*

    This vector contains the all connections from an object.

    Each object may have one vector containing the lists of

    connections for a given signal. The index in the vector correspond

    to the signal index. The signal index is the one returned by

    QObjectPrivate::signalIndex (not QMetaObject::indexOfSignal).

    Negative index means connections to all signals.

    This vector is protected by the object mutex (signalSlotMutexes())

    Each Connection is also part of a 'senders' linked list. The mutex

    of the receiver must be locked when touching the pointers of this

    linked list.

*/

class QObjectConnectionListVector : public QVector<QObjectPrivate::ConnectionList>

{

public:

    bool orphaned; //the QObject owner of this vector has been destroyed while the vector was inUse

    bool dirty; //some Connection have been disconnected (their receiver is 0) but not removed from the list yet

    int inUse; //number of functions that are currently accessing this object or its connections

    QObjectPrivate::ConnectionList allsignals;

    QObjectConnectionListVector()

        : QVector<QObjectPrivate::ConnectionList>(), orphaned(false), dirty(false), inUse(0)

    { }

    QObjectPrivate::ConnectionList &operator[](int at)

    {

        if (at < 0)

            return allsignals;

        return QVector<QObjectPrivate::ConnectionList>::operator[](at);

    }

};

// Used by QAccessibleWidget

bool QObjectPrivate::isSender(const QObject *receiver, const char *signal) const

{

    Q_Q(const QObject);

    int signal_index = signalIndex(signal);

    if (signal_index < 0)

        return false;

    QMutexLocker locker(signalSlotLock(q));

    if (connectionLists) {

        if (signal_index < connectionLists->count()) {

            const QObjectPrivate::Connection *c =

                connectionLists->at(signal_index).first;

            while (c) {

                if (c->receiver == receiver)

                    return true;

                c = c->nextConnectionList;

            }

        }

    }

    return false;

}

// Used by QAccessibleWidget

QObjectList QObjectPrivate::receiverList(const char *signal) const

{

    Q_Q(const QObject);

    QObjectList returnValue;

    int signal_index = signalIndex(signal);

    if (signal_index < 0)

        return returnValue;

    QMutexLocker locker(signalSlotLock(q));

    if (connectionLists) {

        if (signal_index < connectionLists->count()) {

            const QObjectPrivate::Connection *c = connectionLists->at(signal_index).first;

            while (c) {

                if (c->receiver)

                    returnValue << c->receiver;

                c = c->nextConnectionList;

            }

        }

    }

    return returnValue;

}

// Used by QAccessibleWidget

QObjectList QObjectPrivate::senderList() const

{

    QObjectList returnValue;

    QMutexLocker locker(signalSlotLock(q_func()));

    for (Connection *c = senders; c; c = c->next)

        returnValue << c->sender;

    return returnValue;

}

void QObjectPrivate::addConnection(int signal, Connection *c)

{

    if (!connectionLists)

        connectionLists = new QObjectConnectionListVector();

    if (signal >= connectionLists->count())

        connectionLists->resize(signal + 1);

    ConnectionList &connectionList = (*connectionLists)[signal];

    if (connectionList.last) {

        connectionList.last->nextConnectionList = c;

    } else {

        connectionList.first = c;

    }

    connectionList.last = c;

    cleanConnectionLists();

}

void QObjectPrivate::cleanConnectionLists()

{

    if (connectionLists->dirty && !connectionLists->inUse) {

        // remove broken connections

        for (int signal = -1; signal < connectionLists->count(); ++signal) {

            QObjectPrivate::ConnectionList &connectionList =

                (*connectionLists)[signal];

            // Set to the last entry in the connection list that was *not*

            // deleted.  This is needed to update the list's last pointer

            // at the end of the cleanup.

            QObjectPrivate::Connection *last = 0;

            QObjectPrivate::Connection **prev = &connectionList.first;

            QObjectPrivate::Connection *c = *prev;

            while (c) {

                if (c->receiver) {

                    last = c;

                    prev = &c->nextConnectionList;

                    c = *prev;

                } else {

                    QObjectPrivate::Connection *next = c->nextConnectionList;

                    *prev = next;

                    delete c;

                    c = next;

                }

            }

            // Correct the connection list's last pointer.

            // As conectionList.last could equal last, this could be a noop

            connectionList.last = last;

        }

        connectionLists->dirty = false;

    }

}

typedef QMultiHash<QObject *, QObject **> GuardHash;

Q_GLOBAL_STATIC(GuardHash, guardHash)

Q_GLOBAL_STATIC(QMutex, guardHashLock)

/*!\internal

 */

void QMetaObject::addGuard(QObject **ptr)

{

    if (!*ptr)

        return;

    GuardHash *hash = guardHash();

    if (!hash) {

        *ptr = 0;

        return;

    }

    QMutexLocker locker(guardHashLock());

    QObjectPrivate::get(*ptr)->hasGuards = true;

    hash->insert(*ptr, ptr);

}

/*!\internal

 */

void QMetaObject::removeGuard(QObject **ptr)

{

    if (!*ptr)

        return;

    GuardHash *hash = guardHash();

    /* check that the hash is empty - otherwise we might detach

       the shared_null hash, which will alloc, which is not nice */

    if (!hash || hash->isEmpty())

        return;

    QMutexLocker locker(guardHashLock());

    if (!*ptr) //check again, under the lock

        return;

    GuardHash::iterator it = hash->find(*ptr);

    const GuardHash::iterator end = hash->end();

    bool more = false; //if the QObject has more pointer attached to it.

    for (; it.key() == *ptr && it != end; ++it) {

        if (it.value() == ptr) {

            it = hash->erase(it);

            if (!more) more = (it != end && it.key() == *ptr);

            break;

        }

        more = true;

    }

    if (!more)

        QObjectPrivate::get(*ptr)->hasGuards = false;

}

/*!\internal

 */

void QMetaObject::changeGuard(QObject **ptr, QObject *o)

{

    GuardHash *hash = guardHash();

    if (!hash) {

        *ptr = 0;

        return;

    }

    QMutexLocker locker(guardHashLock());

    if (o) {

        hash->insert(o, ptr);

        QObjectPrivate::get(o)->hasGuards = true;

    }

    if (*ptr) {

        bool more = false; //if the QObject has more pointer attached to it.

        GuardHash::iterator it = hash->find(*ptr);

        const GuardHash::iterator end = hash->end();

        for (; it.key() == *ptr && it != end; ++it) {

            if (it.value() == ptr) {

                it = hash->erase(it);

                if (!more) more = (it != end && it.key() == *ptr);

                break;

            }

            more = true;

        }

        if (!more)

            QObjectPrivate::get(*ptr)->hasGuards = false;

    }

    *ptr = o;

}

/*! \internal

 */

void QObjectPrivate::clearGuards(QObject *object)

{

    GuardHash *hash = 0;

    QMutex *mutex = 0;

    QT_TRY {

        hash = guardHash();

        mutex = guardHashLock();

    } QT_CATCH(const std::bad_alloc &) {

        // do nothing in case of OOM - code below is safe

    }

    /* check that the hash is empty - otherwise we might detach

       the shared_null hash, which will alloc, which is not nice */

    if (hash && !hash->isEmpty()) {

        QMutexLocker locker(mutex);

        GuardHash::iterator it = hash->find(object);

        const GuardHash::iterator end = hash->end();

        while (it.key() == object && it != end) {

            *it.value() = 0;

            it = hash->erase(it);

        }

    }

}

/*! \internal

 */

QMetaCallEvent::QMetaCallEvent(ushort method_offset, ushort method_relative, QObjectPrivate::StaticMetaCallFunction callFunction,

                               const QObject *sender, int signalId,

                               int nargs, int *types, void **args, QSemaphore *semaphore)

    : QEvent(MetaCall), sender_(sender), signalId_(signalId),

      nargs_(nargs), types_(types), args_(args), semaphore_(semaphore),

      callFunction_(callFunction), method_offset_(method_offset), method_relative_(method_relative)

{ }

/*! \internal

 */

QMetaCallEvent::~QMetaCallEvent()

{

    if (types_) {

        for (int i = 0; i < nargs_; ++i) {

            if (types_[i] && args_[i])

                QMetaType::destroy(types_[i], args_[i]);

        }

        qFree(types_);

        qFree(args_);

    }

#ifndef QT_NO_THREAD

    if (semaphore_)

        semaphore_->release();

#endif

}

/*! \internal

 */

void QMetaCallEvent::placeMetaCall(QObject *object)

{

    if (callFunction_) {

        callFunction_(object, QMetaObject::InvokeMetaMethod, method_relative_, args_);

    } else {

        QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, method_offset_ + method_relative_, args_);

    }

}

/*!

    \class QObject

    \brief The QObject class is the base class of all Qt objects.

    \ingroup objectmodel

    \reentrant

    QObject is the heart of the Qt \l{Object Model}. The central

    feature in this model is a very powerful mechanism for seamless

    object communication called \l{signals and slots}. You can

    connect a signal to a slot with connect() and destroy the

    connection with disconnect(). To avoid never ending notification

    loops you can temporarily block signals with blockSignals(). The

    protected functions connectNotify() and disconnectNotify() make

    it possible to track connections.

    QObjects organize themselves in \l {Object Trees & Ownership}

    {object trees}. When you create a QObject with another object as

    parent, the object will automatically add itself to the parent's

    children() list. The parent takes ownership of the object; i.e.,

    it will automatically delete its children in its destructor. You

    can look for an object by name and optionally type using

    findChild() or findChildren().

    Every object has an objectName() and its class name can be found

    via the corresponding metaObject() (see QMetaObject::className()).

    You can determine whether the object's class inherits another

    class in the QObject inheritance hierarchy by using the

    inherits() function.

    When an object is deleted, it emits a destroyed() signal. You can

    catch this signal to avoid dangling references to QObjects.

    QObjects can receive events through event() and filter the events

    of other objects. See installEventFilter() and eventFilter() for

    details. A convenience handler, childEvent(), can be reimplemented

    to catch child events.

    Events are delivered in the thread in which the object was

    created; see \l{Thread Support in Qt} and thread() for details.

    Note that event processing is not done at all for QObjects with no

    thread affinity (thread() returns zero). Use the moveToThread()

    function to change the thread affinity for an object and its

    children (the object cannot be moved if it has a parent).

    Last but not least, QObject provides the basic timer support in

    Qt; see QTimer for high-level support for timers.

    Notice that the Q_OBJECT macro is mandatory for any object that

    implements signals, slots or properties. You also need to run the

    \l{moc}{Meta Object Compiler} on the source file. We strongly

    recommend the use of this macro in all subclasses of QObject

    regardless of whether or not they actually use signals, slots and

    properties, since failure to do so may lead certain functions to

    exhibit strange behavior.

    All Qt widgets inherit QObject. The convenience function

    isWidgetType() returns whether an object is actually a widget. It

    is much faster than

    \l{qobject_cast()}{qobject_cast}<QWidget *>(\e{obj}) or

    \e{obj}->\l{inherits()}{inherits}("QWidget").

    Some QObject functions, e.g. children(), return a QObjectList.

    QObjectList is a typedef for QList<QObject *>.

    \target No copy constructor

    \section1 No copy constructor or assignment operator

    QObject has neither a copy constructor nor an assignment operator.

    This is by design. Actually, they are declared, but in a

    \c{private} section with the macro Q_DISABLE_COPY(). In fact, all

    Qt classes derived from QObject (direct or indirect) use this

    macro to declare their copy constructor and assignment operator to

    be private. The reasoning is found in the discussion on

    \l{Identity vs Value} {Identity vs Value} on the Qt \l{Object

    Model} page.

    The main consequence is that you should use pointers to QObject

    (or to your QObject subclass) where you might otherwise be tempted

    to use your QObject subclass as a value. For example, without a

    copy constructor, you can't use a subclass of QObject as the value

    to be stored in one of the container classes. You must store

    pointers.

    \section1 Auto-Connection

    Qt's meta-object system provides a mechanism to automatically connect

    signals and slots between QObject subclasses and their children. As long

    as objects are defined with suitable object names, and slots follow a

    simple naming convention, this connection can be performed at run-time

    by the QMetaObject::connectSlotsByName() function.

    \l uic generates code that invokes this function to enable

    auto-connection to be performed between widgets on forms created

    with \QD. More information about using auto-connection with \QD is

    given in the \l{Using a Designer UI File in Your Application} section of

    the \QD manual.

    \section1 Dynamic Properties

    From Qt 4.2, dynamic properties can be added to and removed from QObject

    instances at run-time. Dynamic properties do not need to be declared at

    compile-time, yet they provide the same advantages as static properties

    and are manipulated using the same API - using property() to read them

    and setProperty() to write them.

    From Qt 4.3, dynamic properties are supported by

    \l{Qt Designer's Widget Editing Mode#The Property Editor}{Qt Designer},

    and both standard Qt widgets and user-created forms can be given dynamic

    properties.

    \section1 Internationalization (i18n)

    All QObject subclasses support Qt's translation features, making it possible

    to translate an application's user interface into different languages.

    To make user-visible text translatable, it must be wrapped in calls to

    the tr() function. This is explained in detail in the

    \l{Writing Source Code for Translation} document.

    \sa QMetaObject, QPointer, QObjectCleanupHandler, Q_DISABLE_COPY()

    \sa {Object Trees & Ownership}

*/

/*!

    \relates QObject

    Returns a pointer to the object named \a name that inherits \a

    type and with a given \a parent.

    Returns 0 if there is no such child.

    \snippet doc/src/snippets/code/src_corelib_kernel_qobject.cpp 0

*/

void *qt_find_obj_child(QObject *parent, const char *type, const QString &name)

{

    QObjectList list = parent->children();

    if (list.size() == 0) return 0;

    for (int i = 0; i < list.size(); ++i) {

        QObject *obj = list.at(i);

        if (name == obj->objectName() && obj->inherits(type))

            return obj;

    }

    return 0;

}

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

  QObject member functions

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

// check the constructor's parent thread argument

static bool check_parent_thread(QObject *parent,

                                QThreadData *parentThreadData,

                                QThreadData *currentThreadData)

{

    if (parent && parentThreadData != currentThreadData) {

        QThread *parentThread = parentThreadData->thread;

        QThread *currentThread = currentThreadData->thread;

        qWarning("QObject: Cannot create children for a parent that is in a different thread.\n"

                 "(Parent is %s(%p), parent's thread is %s(%p), current thread is %s(%p)",

                 parent->metaObject()->className(),

                 parent,

                 parentThread ? parentThread->metaObject()->className() : "QThread",

                 parentThread,

                 currentThread ? currentThread->metaObject()->className() : "QThread",

                 currentThread);

        return false;

    }

    return true;

}

/*!

    Constructs an object with parent object \a parent.

    The parent of an object may be viewed as the object's owner. For

    instance, a \l{QDialog}{dialog box} is the parent of the \gui OK

    and \gui Cancel buttons it contains.

    The destructor of a parent object destroys all child objects.

    Setting \a parent to 0 constructs an object with no parent. If the

    object is a widget, it will become a top-level window.

    \sa parent(), findChild(), findChildren()

*/

QObject::QObject(QObject *parent)

    : d_ptr(new QObjectPrivate)

{

    Q_D(QObject);

    d_ptr->q_ptr = this;

    d->threadData = (parent && !parent->thread()) ? parent->d_func()->threadData : QThreadData::current();

    d->threadData->ref();

    if (parent) {

        QT_TRY {

            if (!check_parent_thread(parent, parent ? parent->d_func()->threadData : 0, d->threadData))

                parent = 0;

            setParent(parent);

        } QT_CATCH(...) {

            d->threadData->deref();

            QT_RETHROW;

        }

    }

    qt_addObject(this);

}

#ifdef QT3_SUPPORT

/*!

    \overload QObject()

    \obsolete

    Creates a new QObject with the given \a parent and object \a name.

 */

QObject::QObject(QObject *parent, const char *name)

    : d_ptr(new QObjectPrivate)

{

    Q_D(QObject);

    qt_addObject(d_ptr->q_ptr = this);

    d->threadData = (parent && !parent->thread()) ? parent->d_func()->threadData : QThreadData::current();

    d->threadData->ref();

    if (parent) {

        if (!check_parent_thread(parent, parent ? parent->d_func()->threadData : 0, d->threadData))

            parent = 0;

        setParent(parent);

    }

    setObjectName(QString::fromAscii(name));

}

#endif

/*! \internal

 */

QObject::QObject(QObjectPrivate &dd, QObject *parent)

    : d_ptr(&dd)

{

    Q_D(QObject);

    d_ptr->q_ptr = this;

    d->threadData = (parent && !parent->thread()) ? parent->d_func()->threadData : QThreadData::current();

    d->threadData->ref();

    if (parent) {

        QT_TRY {

            if (!check_parent_thread(parent, parent ? parent->d_func()->threadData : 0, d->threadData))

                parent = 0;

            if (d->isWidget) {

                if (parent) {

                    d->parent = parent;

                    d->parent->d_func()->children.append(this);

                }

                // no events sent here, this is done at the end of the QWidget constructor

            } else {

                setParent(parent);

            }

        } QT_CATCH(...) {

            d->threadData->deref();

            QT_RETHROW;

        }

    }

    qt_addObject(this);

}

/*!

    Destroys the object, deleting all its child objects.

    All signals to and from the object are automatically disconnected, and

    any pending posted events for the object are removed from the event

    queue. However, it is often safer to use deleteLater() rather than

    deleting a QObject subclass directly.

    \warning All child objects are deleted. If any of these objects

    are on the stack or global, sooner or later your program will

    crash. We do not recommend holding pointers to child objects from

    outside the parent. If you still do, the destroyed() signal gives

    you an opportunity to detect when an object is destroyed.

    \warning Deleting a QObject while pending events are waiting to

    be delivered can cause a crash. You must not delete the QObject

    directly if it exists in a different thread than the one currently

    executing. Use deleteLater() instead, which will cause the event

    loop to delete the object after all pending events have been

    delivered to it.

    \sa deleteLater()

*/

QObject::~QObject()

{

    Q_D(QObject);

    d->wasDeleted = true;

    d->blockSig = 0; // unblock signals so we always emit destroyed()

    if (d->hasGuards && !d->isWidget) {

        // set all QPointers for this object to zero - note that

        // ~QWidget() does this for us, so we don't have to do it twice

        QObjectPrivate::clearGuards(this);

    }

    if (d->sharedRefcount) {

        if (d->sharedRefcount->strongref > 0) {

            qWarning("QObject: shared QObject was deleted directly. The program is malformed and may crash.");

            // but continue deleting, it's too late to stop anyway

        }

        // indicate to all QWeakPointers that this QObject has now been deleted

        d->sharedRefcount->strongref = 0;

        if (!d->sharedRefcount->weakref.deref())

            delete d->sharedRefcount;

    }

    if (d->isSignalConnected(0)) {

        QT_TRY {

            emit destroyed(this);

        } QT_CATCH(...) {

            // all the signal/slots connections are still in place - if we don't

            // quit now, we will crash pretty soon.

            qWarning("Detected an unexpected exception in ~QObject while emitting destroyed().");

            QT_RETHROW;

        }

    }

    if (d->declarativeData)

        QAbstractDeclarativeData::destroyed(d->declarativeData, this);

    // set ref to zero to indicate that this object has been deleted

    if (d->currentSender != 0)

        d->currentSender->ref = 0;

    d->currentSender = 0;

    if (d->connectionLists || d->senders) {

        QMutex *signalSlotMutex = signalSlotLock(this);

        QMutexLocker locker(signalSlotMutex);

        // disconnect all receivers

        if (d->connectionLists) {

            ++d->connectionLists->inUse;

            int connectionListsCount = d->connectionLists->count();

            for (int signal = -1; signal < connectionListsCount; ++signal) {

                QObjectPrivate::ConnectionList &connectionList =

                    (*d->connectionLists)[signal];

                while (QObjectPrivate::Connection *c = connectionList.first) {

                    if (!c->receiver) {

                        connectionList.first = c->nextConnectionList;

                        delete c;

                        continue;

                    }

                    QMutex *m = signalSlotLock(c->receiver);

                    bool needToUnlock = QOrderedMutexLocker::relock(signalSlotMutex, m);

                    if (c->receiver) {

                        *c->prev = c->next;

                        if (c->next) c->next->prev = c->prev;

                    }

                    if (needToUnlock)

                        m->unlockInline();

                    connectionList.first = c->nextConnectionList;

                    delete c;

                }

            }

            if (!--d->connectionLists->inUse) {

                delete d->connectionLists;

            } else {

                d->connectionLists->orphaned = true;

            }

            d->connectionLists = 0;

        }

        // disconnect all senders

        QObjectPrivate::Connection *node = d->senders;

        while (node) {

            QObject *sender = node->sender;

            QMutex *m = signalSlotLock(sender);

            node->prev = &node;

            bool needToUnlock = QOrderedMutexLocker::relock(signalSlotMutex, m);

            //the node has maybe been removed while the mutex was unlocked in relock?

            if (!node || node->sender != sender) {

                m->unlockInline();

                continue;

            }

            node->receiver = 0;

            QObjectConnectionListVector *senderLists = sender->d_func()->connectionLists;

            if (senderLists)

                senderLists->dirty = true;

            node = node->next;

            if (needToUnlock)

                m->unlockInline();

        }

    }

    if (!d->children.isEmpty())

        d->deleteChildren();

    qt_removeObject(this);

    if (d->parent)        // remove it from parent object

        d->setParent_helper(0);

#ifdef QT_JAMBI_BUILD

    if (d->inEventHandler) {

        qWarning("QObject: Do not delete object, '%s', during its event handler!",

                 objectName().isNull() ? "unnamed" : qPrintable(objectName()));

    }

#endif

}

QObjectPrivate::Connection::~Connection()

{

    if (argumentTypes != &DIRECT_CONNECTION_ONLY)

        delete [] static_cast<int *>(argumentTypes);

}

/*!

    \fn QMetaObject *QObject::metaObject() const

    Returns a pointer to the meta-object of this object.

    A meta-object contains information about a class that inherits

    QObject, e.g. class name, superclass name, properties, signals and

    slots. Every QObject subclass that contains the Q_OBJECT macro will have a

    meta-object.

    The meta-object information is required by the signal/slot

    connection mechanism and the property system. The inherits()

    function also makes use of the meta-object.

    If you have no pointer to an actual object instance but still

    want to access the meta-object of a class, you can use \l

    staticMetaObject.

    Example:

    \snippet doc/src/snippets/code/src_corelib_kernel_qobject.cpp 1

    \sa staticMetaObject

*/

/*!

    \variable QObject::staticMetaObject

    This variable stores the meta-object for the class.

    A meta-object contains information about a class that inherits

    QObject, e.g. class name, superclass name, properties, signals and

    slots. Every class that contains the Q_OBJECT macro will also have

    a meta-object.

    The meta-object information is required by the signal/slot

    connection mechanism and the property system. The inherits()

    function also makes use of the meta-object.

    If you have a pointer to an object, you can use metaObject() to

    retrieve the meta-object associated with that object.

    Example:

    \snippet doc/src/snippets/code/src_corelib_kernel_qobject.cpp 2

    \sa metaObject()

*/

/*! \fn T *qobject_cast<T *>(QObject *object)

    \relates QObject

    Returns the given \a object cast to type T if the object is of type

    T (or of a subclass); otherwise returns 0.  If \a object is 0 then 

    it will also return 0.

    The class T must inherit (directly or indirectly) QObject and be

    declared with the \l Q_OBJECT macro.

    A class is considered to inherit itself.

    Example:

    \snippet doc/src/snippets/code/src_corelib_kernel_qobject.cpp 3

    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.

    qobject_cast() can also be used in conjunction with interfaces;

    see the \l{tools/plugandpaint}{Plug & Paint} example for details.

    \warning If T isn't declared with the Q_OBJECT macro, this

    function's return value is undefined.

    \sa QObject::inherits()

*/

/*!

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

    Returns true if this object is an instance of a class that

    inherits \a className or a QObject subclass that inherits \a

    className; otherwise returns false.

    A class is considered to inherit itself.

    Example:

    \snippet doc/src/snippets/code/src_corelib_kernel_qobject.cpp 4

    If you need to determine whether an object is an instance of a particular

    class for the purpose of casting it, consider using qobject_cast<Type *>(object)

    instead.

    \sa metaObject(), qobject_cast()

*/

/*!

    \property QObject::objectName

    \brief the name of this object

    You can find an object by name (and type) using findChild(). You can

    find a set of objects with findChildren().

    \snippet doc/src/snippets/code/src_corelib_kernel_qobject.cpp 5

    By default, this property contains an empty string.

    \sa metaObject(), QMetaObject::className()

*/

QString QObject::objectName() const

{

    Q_D(const QObject);

    return d->objectName;

}

/*

    Sets the object's name to \a name.

*/

void QObject::setObjectName(const QString &name)

{

    Q_D(QObject);

    bool objectNameChanged = d->declarativeData && d->objectName != name;

    d->objectName = name;

    if (objectNameChanged) 

        d->declarativeData->objectNameChanged(d->declarativeData, this);

}

#ifdef QT3_SUPPORT

/*! \internal

    QObject::child is compat but needs to call itself recursively,

    that's why we need this helper.

*/

static QObject *qChildHelper(const char *objName, const char *inheritsClass,

                             bool recursiveSearch, const QObjectList &children)

{

    if (children.isEmpty())

        return 0;

    bool onlyWidgets = (inheritsClass && qstrcmp(inheritsClass, "QWidget") == 0);

    const QLatin1String oName(objName);

    for (int i = 0; i < children.size(); ++i) {

        QObject *obj = children.at(i);

        if (onlyWidgets) {

            if (obj->isWidgetType() && (!objName || obj->objectName() == oName))

                return obj;

        } else if ((!inheritsClass || obj->inherits(inheritsClass))

                   && (!objName || obj->objectName() == oName))

            return obj;

        if (recursiveSearch && (obj = qChildHelper(objName, inheritsClass,

                                                   recursiveSearch, obj->children())))

            return obj;

    }

    return 0;

}

/*!

    Searches the children and optionally grandchildren of this object,

    and returns a child that is called \a objName that inherits \a

    inheritsClass. If \a inheritsClass is 0 (the default), any class

    matches.

    If \a recursiveSearch is true (the default), child() performs a

    depth-first search of the object's children.

    If there is no such object, this function returns 0. If there are

    more than one, the first one found is returned.

*/

QObject* QObject::child(const char *objName, const char *inheritsClass,

                        bool recursiveSearch) const

{

    Q_D(const QObject);

    return qChildHelper(objName, inheritsClass, recursiveSearch, d->children);

}

#endif

/*!

    \fn bool QObject::isWidgetType() const

    Returns true if the object is a widget; otherwise returns false.

    Calling this function is equivalent to calling

    inherits("QWidget"), except that it is much faster.

*/

/*!

    This virtual function receives events to an object and should

    return true if the event \a e was recognized and processed.

    The event() function can be reimplemented to customize the

    behavior of an object.

    \sa installEventFilter(), timerEvent(), QApplication::sendEvent(),

    QApplication::postEvent(), QWidget::event()

*/

bool QObject::event(QEvent *e)

{

    switch (e->type()) {

    case QEvent::Timer:

        timerEvent((QTimerEvent*)e);

        break;

#ifdef QT3_SUPPORT

    case QEvent::ChildInsertedRequest:

        d_func()->sendPendingChildInsertedEvents();

        break;

#endif

    case QEvent::ChildAdded:

    case QEvent::ChildPolished:

#ifdef QT3_SUPPORT

    case QEvent::ChildInserted:

#endif

    case QEvent::ChildRemoved:

        childEvent((QChildEvent*)e);

        break;

    case QEvent::DeferredDelete:

        qDeleteInEventHandler(this);

        break;

    case QEvent::MetaCall:

        {

#ifdef QT_JAMBI_BUILD

            d_func()->inEventHandler = false;

#endif

            QMetaCallEvent *mce = static_cast<QMetaCallEvent*>(e);

            QObjectPrivate::Sender currentSender;

            currentSender.sender = const_cast<QObject*>(mce->sender());

            currentSender.signal = mce->signalId();

            currentSender.ref = 1;

            QObjectPrivate::Sender * const previousSender =

                QObjectPrivate::setCurrentSender(this, &currentSender);

#if defined(QT_NO_EXCEPTIONS)

            mce->placeMetaCall(this);

#else

            QT_TRY {

                mce->placeMetaCall(this);

            } QT_CATCH(...) {

                QObjectPrivate::resetCurrentSender(this, &currentSender, previousSender);

                QT_RETHROW;

            }

#endif

            QObjectPrivate::resetCurrentSender(this, &currentSender, previousSender);

            break;

        }

    case QEvent::ThreadChange: {

        Q_D(QObject);

        QThreadData *threadData = d->threadData;

        QAbstractEventDispatcher *eventDispatcher = threadData->eventDispatcher;

        if (eventDispatcher) {

            QList<QPair<int, int> > timers = eventDispatcher->registeredTimers(this);

            if (!timers.isEmpty()) {

                // set inThreadChangeEvent to true to tell the dispatcher not to release out timer ids

                // back to the pool (since the timer ids are moving to a new thread).

                d->inThreadChangeEvent = true;

                eventDispatcher->unregisterTimers(this);

                d->inThreadChangeEvent = false;

                QMetaObject::invokeMethod(this, "_q_reregisterTimers", Qt::QueuedConnection,

                                          Q_ARG(void*, (new QList<QPair<int, int> >(timers))));

            }

        }

        break;

    }

    default:

        if (e->type() >= QEvent::User) {

            customEvent(e);

            break;

        }

        return false;

    }

    return true;

}

/*!

    \fn void QObject::timerEvent(QTimerEvent *event)