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

**

** 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 tools applications 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$

**

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

#include "qtvariantproperty.h"

#include "qtpropertymanager.h"

#include "qteditorfactory.h"

#include <QtCore/QVariant>

#include <QtGui/QIcon>

#include <QtCore/QDate>

#include <QtCore/QLocale>

#if defined(Q_CC_MSVC)

#    pragma warning(disable: 4786) /* MS VS 6: truncating debug info after 255 characters */

#endif

QT_BEGIN_NAMESPACE

class QtEnumPropertyType

{

};

class QtFlagPropertyType

{

};

class QtGroupPropertyType

{

};

QT_END_NAMESPACE

Q_DECLARE_METATYPE(QtEnumPropertyType)

Q_DECLARE_METATYPE(QtFlagPropertyType)

Q_DECLARE_METATYPE(QtGroupPropertyType)

QT_BEGIN_NAMESPACE

/*!

    Returns the type id for an enum property.

    Note that the property's value type can be retrieved using the

    valueType() function (which is QVariant::Int for the enum property

    type).

    \sa propertyType(), valueType()

*/

int QtVariantPropertyManager::enumTypeId()

{

    return qMetaTypeId<QtEnumPropertyType>();

}

/*!

    Returns the type id for a flag property.

    Note that the property's value type can be retrieved using the

    valueType() function (which is QVariant::Int for the flag property

    type).

    \sa propertyType(), valueType()

*/

int QtVariantPropertyManager::flagTypeId()

{

    return qMetaTypeId<QtFlagPropertyType>();

}

/*!

    Returns the type id for a group property.

    Note that the property's value type can be retrieved using the

    valueType() function (which is QVariant::Invalid for the group

    property type, since it doesn't provide any value).

    \sa propertyType(), valueType()

*/

int QtVariantPropertyManager::groupTypeId()

{

    return qMetaTypeId<QtGroupPropertyType>();

}

/*!

    Returns the type id for a icon map attribute.

    Note that the property's attribute type can be retrieved using the

    attributeType() function.

    \sa attributeType(), QtEnumPropertyManager::enumIcons()

*/

int QtVariantPropertyManager::iconMapTypeId()

{

    return qMetaTypeId<QtIconMap>();

}

typedef QMap<const QtProperty *, QtProperty *> PropertyMap;

Q_GLOBAL_STATIC(PropertyMap, propertyToWrappedProperty)

static QtProperty *wrappedProperty(QtProperty *property)

{

    return propertyToWrappedProperty()->value(property, 0);

}

class QtVariantPropertyPrivate

{

    QtVariantProperty *q_ptr;

public:

    QtVariantPropertyPrivate(QtVariantPropertyManager *m) : manager(m) {}

    QtVariantPropertyManager *manager;

};

/*!

    \class QtVariantProperty

    \internal

    \inmodule QtDesigner

    \since 4.4

    \brief The QtVariantProperty class is a convenience class handling

    QVariant based properties.

    QtVariantProperty provides additional API: A property's type,

    value type, attribute values and current value can easily be

    retrieved using the propertyType(), valueType(), attributeValue()

    and value() functions respectively. In addition, the attribute

    values and the current value can be set using the corresponding

    setValue() and setAttribute() functions.

    For example, instead of writing:

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

    you can write:

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

    QtVariantProperty instances can only be created by the

    QtVariantPropertyManager class.

    \sa QtProperty, QtVariantPropertyManager, QtVariantEditorFactory

*/

/*!

    Creates a variant property using the given \a manager.

    Do not use this constructor to create variant property instances;

    use the QtVariantPropertyManager::addProperty() function

    instead.  This constructor is used internally by the

    QtVariantPropertyManager::createProperty() function.

    \sa QtVariantPropertyManager

*/

QtVariantProperty::QtVariantProperty(QtVariantPropertyManager *manager)

    : QtProperty(manager), d_ptr(new QtVariantPropertyPrivate(manager))

{

}

/*!

    Destroys this property.

    \sa QtProperty::~QtProperty()

*/

QtVariantProperty::~QtVariantProperty()

{

}

/*!

    Returns the property's current value.

    \sa valueType(), setValue()

*/

QVariant QtVariantProperty::value() const

{

    return d_ptr->manager->value(this);

}

/*!

    Returns this property's value for the specified \a attribute.

    QtVariantPropertyManager provides a couple of related functions:

    \l{QtVariantPropertyManager::attributes()}{attributes()} and

    \l{QtVariantPropertyManager::attributeType()}{attributeType()}.

    \sa setAttribute()

*/

QVariant QtVariantProperty::attributeValue(const QString &attribute) const

{

    return d_ptr->manager->attributeValue(this, attribute);

}

/*!

    Returns the type of this property's value.

    \sa propertyType()

*/

int QtVariantProperty::valueType() const

{

    return d_ptr->manager->valueType(this);

}

/*!

    Returns this property's type.

    QtVariantPropertyManager provides several related functions:

    \l{QtVariantPropertyManager::enumTypeId()}{enumTypeId()},

    \l{QtVariantPropertyManager::flagTypeId()}{flagTypeId()} and

    \l{QtVariantPropertyManager::groupTypeId()}{groupTypeId()}.

    \sa valueType()

*/

int QtVariantProperty::propertyType() const

{

    return d_ptr->manager->propertyType(this);

}

/*!

    Sets the value of this property to \a value.

    The specified \a value must be of the type returned by

    valueType(), or of a type that can be converted to valueType()

    using the QVariant::canConvert() function; otherwise this function

    does nothing.

    \sa value()

*/

void QtVariantProperty::setValue(const QVariant &value)

{

    d_ptr->manager->setValue(this, value);

}

/*!

    Sets the \a attribute of property to \a value.

    QtVariantPropertyManager provides the related

    \l{QtVariantPropertyManager::setAttribute()}{setAttribute()}

    function.

    \sa attributeValue()

*/

void QtVariantProperty::setAttribute(const QString &attribute, const QVariant &value)

{

    d_ptr->manager->setAttribute(this, attribute, value);

}

class QtVariantPropertyManagerPrivate

{

    QtVariantPropertyManager *q_ptr;

    Q_DECLARE_PUBLIC(QtVariantPropertyManager)

public:

    QtVariantPropertyManagerPrivate();

    bool m_creatingProperty;

    bool m_creatingSubProperties;

    bool m_destroyingSubProperties;

    int m_propertyType;

    void slotValueChanged(QtProperty *property, int val);

    void slotRangeChanged(QtProperty *property, int min, int max);

    void slotSingleStepChanged(QtProperty *property, int step);

    void slotValueChanged(QtProperty *property, double val);

    void slotRangeChanged(QtProperty *property, double min, double max);

    void slotSingleStepChanged(QtProperty *property, double step);

    void slotDecimalsChanged(QtProperty *property, int prec);

    void slotValueChanged(QtProperty *property, bool val);

    void slotValueChanged(QtProperty *property, const QString &val);

    void slotRegExpChanged(QtProperty *property, const QRegExp &regExp);

    void slotValueChanged(QtProperty *property, const QDate &val);

    void slotRangeChanged(QtProperty *property, const QDate &min, const QDate &max);

    void slotValueChanged(QtProperty *property, const QTime &val);

    void slotValueChanged(QtProperty *property, const QDateTime &val);

    void slotValueChanged(QtProperty *property, const QKeySequence &val);

    void slotValueChanged(QtProperty *property, const QChar &val);

    void slotValueChanged(QtProperty *property, const QLocale &val);

    void slotValueChanged(QtProperty *property, const QPoint &val);

    void slotValueChanged(QtProperty *property, const QPointF &val);

    void slotValueChanged(QtProperty *property, const QSize &val);

    void slotRangeChanged(QtProperty *property, const QSize &min, const QSize &max);

    void slotValueChanged(QtProperty *property, const QSizeF &val);

    void slotRangeChanged(QtProperty *property, const QSizeF &min, const QSizeF &max);

    void slotValueChanged(QtProperty *property, const QRect &val);

    void slotConstraintChanged(QtProperty *property, const QRect &val);

    void slotValueChanged(QtProperty *property, const QRectF &val);

    void slotConstraintChanged(QtProperty *property, const QRectF &val);

    void slotValueChanged(QtProperty *property, const QColor &val);

    void slotEnumChanged(QtProperty *property, int val);

    void slotEnumNamesChanged(QtProperty *property, const QStringList &enumNames);

    void slotEnumIconsChanged(QtProperty *property, const QMap<int, QIcon> &enumIcons);

    void slotValueChanged(QtProperty *property, const QSizePolicy &val);

    void slotValueChanged(QtProperty *property, const QFont &val);

    void slotValueChanged(QtProperty *property, const QCursor &val);

    void slotFlagChanged(QtProperty *property, int val);

    void slotFlagNamesChanged(QtProperty *property, const QStringList &flagNames);

    void slotPropertyInserted(QtProperty *property, QtProperty *parent, QtProperty *after);

    void slotPropertyRemoved(QtProperty *property, QtProperty *parent);

    void valueChanged(QtProperty *property, const QVariant &val);

    int internalPropertyToType(QtProperty *property) const;

    QtVariantProperty *createSubProperty(QtVariantProperty *parent, QtVariantProperty *after,

            QtProperty *internal);

    void removeSubProperty(QtVariantProperty *property);

    QMap<int, QtAbstractPropertyManager *> m_typeToPropertyManager;

    QMap<int, QMap<QString, int> > m_typeToAttributeToAttributeType;

    QMap<const QtProperty *, QPair<QtVariantProperty *, int> > m_propertyToType;

    QMap<int, int> m_typeToValueType;

    QMap<QtProperty *, QtVariantProperty *> m_internalToProperty;

    const QString m_constraintAttribute;

    const QString m_singleStepAttribute;

    const QString m_decimalsAttribute;

    const QString m_enumIconsAttribute;

    const QString m_enumNamesAttribute;

    const QString m_flagNamesAttribute;

    const QString m_maximumAttribute;

    const QString m_minimumAttribute;

    const QString m_regExpAttribute;

};

QtVariantPropertyManagerPrivate::QtVariantPropertyManagerPrivate() :

    m_constraintAttribute(QLatin1String("constraint")),

    m_singleStepAttribute(QLatin1String("singleStep")),

    m_decimalsAttribute(QLatin1String("decimals")),

    m_enumIconsAttribute(QLatin1String("enumIcons")),

    m_enumNamesAttribute(QLatin1String("enumNames")),

    m_flagNamesAttribute(QLatin1String("flagNames")),

    m_maximumAttribute(QLatin1String("maximum")),

    m_minimumAttribute(QLatin1String("minimum")),

    m_regExpAttribute(QLatin1String("regExp"))

{

}

int QtVariantPropertyManagerPrivate::internalPropertyToType(QtProperty *property) const

{

    int type = 0;

    QtAbstractPropertyManager *internPropertyManager = property->propertyManager();

    if (qobject_cast<QtIntPropertyManager *>(internPropertyManager))

        type = QVariant::Int;

    else if (qobject_cast<QtEnumPropertyManager *>(internPropertyManager))

        type = QtVariantPropertyManager::enumTypeId();

    else if (qobject_cast<QtBoolPropertyManager *>(internPropertyManager))

        type = QVariant::Bool;

    else if (qobject_cast<QtDoublePropertyManager *>(internPropertyManager))

        type = QVariant::Double;

    return type;

}

QtVariantProperty *QtVariantPropertyManagerPrivate::createSubProperty(QtVariantProperty *parent,

            QtVariantProperty *after, QtProperty *internal)

{

    int type = internalPropertyToType(internal);

    if (!type)

        return 0;

    bool wasCreatingSubProperties = m_creatingSubProperties;

    m_creatingSubProperties = true;

    QtVariantProperty *varChild = q_ptr->addProperty(type, internal->propertyName());

    m_creatingSubProperties = wasCreatingSubProperties;

    varChild->setPropertyName(internal->propertyName());

    varChild->setToolTip(internal->toolTip());

    varChild->setStatusTip(internal->statusTip());

    varChild->setWhatsThis(internal->whatsThis());

    parent->insertSubProperty(varChild, after);

    m_internalToProperty[internal] = varChild;

    propertyToWrappedProperty()->insert(varChild, internal);

    return varChild;

}

void QtVariantPropertyManagerPrivate::removeSubProperty(QtVariantProperty *property)

{

    QtProperty *internChild = wrappedProperty(property);

    bool wasDestroyingSubProperties = m_destroyingSubProperties;

    m_destroyingSubProperties = true;

    delete property;

    m_destroyingSubProperties = wasDestroyingSubProperties;

    m_internalToProperty.remove(internChild);

    propertyToWrappedProperty()->remove(property);

}

void QtVariantPropertyManagerPrivate::slotPropertyInserted(QtProperty *property,

            QtProperty *parent, QtProperty *after)

{

    if (m_creatingProperty)

        return;

    QtVariantProperty *varParent = m_internalToProperty.value(parent, 0);

    if (!varParent)

        return;

    QtVariantProperty *varAfter = 0;

    if (after) {

        varAfter = m_internalToProperty.value(after, 0);

        if (!varAfter)

            return;

    }

    createSubProperty(varParent, varAfter, property);

}

void QtVariantPropertyManagerPrivate::slotPropertyRemoved(QtProperty *property, QtProperty *parent)

{

    Q_UNUSED(parent)

    QtVariantProperty *varProperty = m_internalToProperty.value(property, 0);

    if (!varProperty)

        return;

    removeSubProperty(varProperty);

}

void QtVariantPropertyManagerPrivate::valueChanged(QtProperty *property, const QVariant &val)

{

    QtVariantProperty *varProp = m_internalToProperty.value(property, 0);

    if (!varProp)

        return;

    emit q_ptr->valueChanged(varProp, val);

    emit q_ptr->propertyChanged(varProp);

}

void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, int val)

{

    valueChanged(property, QVariant(val));

}

void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, int min, int max)

{

    if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {

        emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));

        emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));

    }

}

void QtVariantPropertyManagerPrivate::slotSingleStepChanged(QtProperty *property, int step)

{

    if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))

        emit q_ptr->attributeChanged(varProp, m_singleStepAttribute, QVariant(step));

}

void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, double val)

{

    valueChanged(property, QVariant(val));

}

void QtVariantPropertyManagerPrivate::slotRangeChanged(QtProperty *property, double min, double max)

{

    if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0)) {

        emit q_ptr->attributeChanged(varProp, m_minimumAttribute, QVariant(min));

        emit q_ptr->attributeChanged(varProp, m_maximumAttribute, QVariant(max));

    }

}

void QtVariantPropertyManagerPrivate::slotSingleStepChanged(QtProperty *property, double step)

{

    if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))

        emit q_ptr->attributeChanged(varProp, m_singleStepAttribute, QVariant(step));

}

void QtVariantPropertyManagerPrivate::slotDecimalsChanged(QtProperty *property, int prec)

{

    if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))

        emit q_ptr->attributeChanged(varProp, m_decimalsAttribute, QVariant(prec));

}

void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, bool val)

{

    valueChanged(property, QVariant(val));

}

void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QString &val)

{

    valueChanged(property, QVariant(val));

}

void QtVariantPropertyManagerPrivate::slotRegExpChanged(QtProperty *property, const QRegExp &regExp)

{

    if (QtVariantProperty *varProp = m_internalToProperty.value(property, 0))

        emit q_ptr->attributeChanged(varProp, m_regExpAttribute, QVariant(regExp));

}

void QtVariantPropertyManagerPrivate::slotValueChanged(QtProperty *property, const QDate &val)

{

    valueChanged(property, QVariant(val));