source: trunk/src/script/qscriptclass.cpp@ 447

/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Qt Software Information ([email protected])
**
** This file is part of the QtScript module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** 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.0, 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.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at [email protected].
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qscriptclass.h"

#ifndef QT_NO_SCRIPT

#include <QtCore/qstringlist.h>

#include "qscriptclasspropertyiterator.h"
#include "qscriptstring.h"
#include "qscriptstring_p.h"
#include "qscriptclass_p.h"
#include "qscriptclassinfo_p.h"
#include "qscriptengine_p.h"
#include "qscriptcontext_p.h"
#include "qscriptvalueimpl_p.h"
#include "qscriptmember_p.h"
#include "qscriptobject_p.h"
#include "qscriptfunction_p.h"

Q_DECLARE_METATYPE(QScriptContext*)
Q_DECLARE_METATYPE(QScriptValueList)

QT_BEGIN_NAMESPACE

/*!
  \since 4.4
  \class QScriptClass

  \brief The QScriptClass class provides an interface for defining custom behavior of (a class of) Qt Script objects.

  \ingroup script
  \mainclass

  The QScriptClass class defines an interface for handling various
  aspects of interaction with the Qt Script objects associated with
  the class. Such objects are created by calling
  QScriptEngine::newObject(), passing a pointer to the QScriptClass as
  argument.

  By subclassing QScriptClass, you can define precisely how access to
  properties of the objects that use your class is handled. This
  enables a fully dynamic handling of properties, e.g. it's more
  powerful than QScriptEngine::newQObject(). For example, you can use
  QScriptClass to implement array-type objects (i.e. objects that
  handle the \c{length} property, and properties whose names are valid
  array indexes, in a special way), or to implement a "live"
  (runtime-defined) proxy to an underlying object.

  If you just need to handle access to a set of properties that are
  known at the time an object is created (i.e. "semi-statically"), you
  might consider using QScriptValue::setProperty() to define
  getter/setter functions for the relevant properties, rather than
  subclassing QScriptClass.

  Reimplement queryProperty() to specify which properties are handled
  in a custom way by your script class (i.e. should be
  \bold{delegated} to the QScriptClass), and which properties should
  be handled just like normal Qt Script object properties.

  Reimplement property() and setProperty() to perform the actual
  access (read or write) to the properties that your class
  handles. Additionally, you can reimplement propertyFlags() to
  specify custom flags for your properties.

  Reimplement newIterator() to provide an iterator for objects of your
  custom class. This is only necessary if objects of your class can
  have custom properties that you want to be reported when an object
  is used together with the QScriptValueIterator class, or when an
  object is used in a for-in enumeration statement in a script.

  When implementing custom classes of objects, you typically use
  QScriptValue::setData() to store instance-specific data as part of
  object initialization; the data won't be accessible from scripts
  directly, but you can access it in e.g. your reimplementations of
  property() and setProperty() (by calling QScriptValue::data()) to
  perform custom processing.

  Reimplement prototype() to provide a custom prototype object for
  your script class.

  Reimplement supportsExtension() and extension() if your custom
  script class supports one or more of the extensions specified by the
  Extension enum.

  \sa QScriptClassPropertyIterator, QScriptEngine::newObject(), {Custom Script Class Example}
*/

/*!
    \enum QScriptClass::Extension

    This enum specifies the possible extensions to a QScriptClass.

    \value Callable Instances of this class can be called as functions.

    \value HasInstance Instances of this class implement [[HasInstance]].

    \sa extension()
*/

/*!
    \enum QScriptClass::QueryFlag

    This enum describes flags that are used to query a QScriptClass
    regarding how access to a property should be handled.

    \value HandlesReadAccess The QScriptClass handles read access to this property.
    \value HandlesWriteAccess The QScriptClass handles write access to this property.

    \sa queryProperty()
*/

class QScriptCustomClassData : public QScriptClassData
{
public:
    QScriptCustomClassData(QScriptClass *klass);
    ~QScriptCustomClassData();

    virtual void mark(const QScriptValueImpl &object, int generation);
    virtual bool resolve(const QScriptValueImpl &object, QScriptNameIdImpl *nameId,
                         QScript::Member *member, QScriptValueImpl *base,
                         QScript::AccessMode access);
    virtual bool get(const QScriptValueImpl &obj, const QScript::Member &m,
                     QScriptValueImpl *result);
    virtual bool put(QScriptValueImpl *object, const QScript::Member &member,
                     const QScriptValueImpl &value);
    virtual bool removeMember(const QScriptValueImpl &object,
                              const QScript::Member &member);
    virtual bool implementsHasInstance(const QScriptValueImpl &object);
    virtual bool hasInstance(const QScriptValueImpl &object,
                             const QScriptValueImpl &value);
    virtual QScriptClassDataIterator *newIterator(const QScriptValueImpl &object);

    QScriptClass *scriptClass() const;

private:
    QScriptClass *m_class;
};

class QScriptCustomClassDataIterator : public QScriptClassDataIterator
{
public:
    QScriptCustomClassDataIterator(const QScriptValueImpl &object,
                                   QScriptClass *klass);
    virtual ~QScriptCustomClassDataIterator();

    virtual bool hasNext() const;
    virtual void next(QScript::Member *member);

    virtual bool hasPrevious() const;
    virtual void previous(QScript::Member *member);

    virtual void toFront();
    virtual void toBack();

private:
    void iteratorToMember(QScript::Member *member);

    QScriptClassPropertyIterator *m_it;
};

QScriptCustomClassData::QScriptCustomClassData(QScriptClass *klass)
    : m_class(klass)
{
}

QScriptCustomClassData::~QScriptCustomClassData()
{
}

void QScriptCustomClassData::mark(const QScriptValueImpl &, int)
{
}

bool QScriptCustomClassData::resolve(const QScriptValueImpl &object, QScriptNameIdImpl *nameId,
                                     QScript::Member *member, QScriptValueImpl *base,
                                     QScript::AccessMode access)
{
    uint id = 0;
    QScriptClass::QueryFlags queryIn = 0;
    if (access & QScript::Read)
        queryIn |= QScriptClass::HandlesReadAccess;
    if (access & QScript::Write)
        queryIn |= QScriptClass::HandlesWriteAccess;
    QScriptEnginePrivate *eng = object.engine();
    QScriptString str = eng->internedString(nameId);
    QScriptClass::QueryFlags queryOut;
    queryOut = m_class->queryProperty(eng->toPublic(object), str, queryIn, &id);
    if (queryOut & queryIn) {
        if (base)
            *base = object;
        QScriptValue::PropertyFlags flags = m_class->propertyFlags(eng->toPublic(object), str, id);
        member->native(nameId, id, flags);
        return true;
    }
    return false;
}

bool QScriptCustomClassData::get(const QScriptValueImpl &object, const QScript::Member &member,
                                 QScriptValueImpl *result)
{
    QScriptEnginePrivate *eng = object.engine();
    QScriptString str = eng->internedString(member.nameId());
    *result = eng->toImpl(m_class->property(eng->toPublic(object), str, member.id()));
    if (!result->isValid())
        *result = eng->undefinedValue();
    return true;
}

bool QScriptCustomClassData::put(QScriptValueImpl *object, const QScript::Member &member,
                                 const QScriptValueImpl &value)
{
    QScriptEnginePrivate *eng = object->engine();
    QScriptString str = eng->internedString(member.nameId());
    QScriptValue publicObject = eng->toPublic(*object);
    m_class->setProperty(publicObject, str, member.id(), eng->toPublic(value));
    return true;
}

bool QScriptCustomClassData::removeMember(const QScriptValueImpl &object,
                                          const QScript::Member &member)
{
    QScriptEnginePrivate *eng = object.engine();
    QScriptString str = eng->internedString(member.nameId());
    QScriptValue publicObject = eng->toPublic(object);
    m_class->setProperty(publicObject, str, member.id(), QScriptValue());
    return true;
}

bool QScriptCustomClassData::implementsHasInstance(const QScriptValueImpl &object)
{
    if (object.classInfo() != QScriptClassPrivate::get(m_class)->classInfo())
        return false;
    return m_class->supportsExtension(QScriptClass::HasInstance);
}

bool QScriptCustomClassData::hasInstance(const QScriptValueImpl &object,
                                         const QScriptValueImpl &value)
{
    QScriptEnginePrivate *eng = object.engine();
    QScriptValueList arguments;
    arguments << eng->toPublic(object) << eng->toPublic(value);
    QVariant ret = m_class->extension(QScriptClass::HasInstance, qVariantFromValue(arguments));
    return ret.toBool();
}

QScriptClassDataIterator *QScriptCustomClassData::newIterator(const QScriptValueImpl &object)
{
    return new QScriptCustomClassDataIterator(object, m_class);
}

QScriptClass *QScriptCustomClassData::scriptClass() const
{
    return m_class;
}



QScriptCustomClassDataIterator::QScriptCustomClassDataIterator(const QScriptValueImpl &object,
                                                               QScriptClass *klass)
{
    QScriptEnginePrivate *eng = object.engine();
    m_it = klass->newIterator(eng->toPublic(object));
}

QScriptCustomClassDataIterator::~QScriptCustomClassDataIterator()
{
    if (m_it) {
        delete m_it;
        m_it = 0;
    }
}

bool QScriptCustomClassDataIterator::hasNext() const
{
    return m_it && m_it->hasNext();
}

void QScriptCustomClassDataIterator::next(QScript::Member *member)
{
    if (m_it) {
        m_it->next();
        iteratorToMember(member);
    }
}

bool QScriptCustomClassDataIterator::hasPrevious() const
{
    return m_it && m_it->hasPrevious();
}

void QScriptCustomClassDataIterator::previous(QScript::Member *member)
{
    if (m_it) {
        m_it->previous();
        iteratorToMember(member);
    }
}

void QScriptCustomClassDataIterator::toFront()
{
    if (m_it)
        m_it->toFront();
}

void QScriptCustomClassDataIterator::toBack()
{
    if (m_it)
        m_it->toBack();
}

void QScriptCustomClassDataIterator::iteratorToMember(QScript::Member *member)
{
    QScriptString str = m_it->name();
    QScriptNameIdImpl *nameId = 0;
    if (str.isValid())
        nameId = QScriptStringPrivate::get(str)->nameId;
    member->native(nameId, m_it->id(), m_it->flags());
}



QScriptClassPrivate::QScriptClassPrivate(QScriptClass *q)
    : engine(0), m_classInfo(0), q_ptr(q)
{
}

QScriptClassPrivate::~QScriptClassPrivate()
{
    if (m_classInfo) {
        // classInfo is owned by engine