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

**

** 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 "qtpropertymanager.h"

#include "qtpropertybrowserutils_p.h"

#include <QtCore/QDateTime>

#include <QtCore/QLocale>

#include <QtCore/QMap>

#include <QtCore/QTimer>

#include <QtGui/QIcon>

#include <QtCore/QMetaEnum>

#include <QtGui/QFontDatabase>

#include <QtGui/QStyleOption>

#include <QtGui/QStyle>

#include <QtGui/QApplication>

#include <QtGui/QPainter>

#include <QtGui/QLabel>

#include <limits.h>

#include <float.h>

#if defined(Q_CC_MSVC)

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

#endif

QT_BEGIN_NAMESPACE

template <class PrivateData, class Value>

static void setSimpleMinimumData(PrivateData *data, const Value &minVal)

{

    data->minVal = minVal;

    if (data->maxVal < data->minVal)

        data->maxVal = data->minVal;

    if (data->val < data->minVal)

        data->val = data->minVal;

}

template <class PrivateData, class Value>

static void setSimpleMaximumData(PrivateData *data, const Value &maxVal)

{

    data->maxVal = maxVal;

    if (data->minVal > data->maxVal)

        data->minVal = data->maxVal;

    if (data->val > data->maxVal)

        data->val = data->maxVal;

}

template <class PrivateData, class Value>

static void setSizeMinimumData(PrivateData *data, const Value &newMinVal)

{

    data->minVal = newMinVal;

    if (data->maxVal.width() < data->minVal.width())

        data->maxVal.setWidth(data->minVal.width());

    if (data->maxVal.height() < data->minVal.height())

        data->maxVal.setHeight(data->minVal.height());

    if (data->val.width() < data->minVal.width())

        data->val.setWidth(data->minVal.width());

    if (data->val.height() < data->minVal.height())

        data->val.setHeight(data->minVal.height());

}

template <class PrivateData, class Value>

static void setSizeMaximumData(PrivateData *data, const Value &newMaxVal)

{

    data->maxVal = newMaxVal;

    if (data->minVal.width() > data->maxVal.width())

        data->minVal.setWidth(data->maxVal.width());

    if (data->minVal.height() > data->maxVal.height())

        data->minVal.setHeight(data->maxVal.height());

    if (data->val.width() > data->maxVal.width())

        data->val.setWidth(data->maxVal.width());

    if (data->val.height() > data->maxVal.height())

        data->val.setHeight(data->maxVal.height());

}

template <class SizeValue>

static SizeValue qBoundSize(const SizeValue &minVal, const SizeValue &val, const SizeValue &maxVal)

{

    SizeValue croppedVal = val;

    if (minVal.width() > val.width())

        croppedVal.setWidth(minVal.width());

    else if (maxVal.width() < val.width())

        croppedVal.setWidth(maxVal.width());

    if (minVal.height() > val.height())

        croppedVal.setHeight(minVal.height());

    else if (maxVal.height() < val.height())

        croppedVal.setHeight(maxVal.height());

    return croppedVal;

}

// Match the exact signature of qBound for VS 6.

QSize qBound(QSize minVal, QSize val, QSize maxVal)

{

    return qBoundSize(minVal, val, maxVal);

}

QSizeF qBound(QSizeF minVal, QSizeF val, QSizeF maxVal)

{

    return qBoundSize(minVal, val, maxVal);

}

namespace {

namespace {

template <class Value>

void orderBorders(Value &minVal, Value &maxVal)

{

    if (minVal > maxVal)

        qSwap(minVal, maxVal);

}

template <class Value>

static void orderSizeBorders(Value &minVal, Value &maxVal)

{

    Value fromSize = minVal;

    Value toSize = maxVal;

    if (fromSize.width() > toSize.width()) {

        fromSize.setWidth(maxVal.width());

        toSize.setWidth(minVal.width());

    }

    if (fromSize.height() > toSize.height()) {

        fromSize.setHeight(maxVal.height());

        toSize.setHeight(minVal.height());

    }

    minVal = fromSize;

    maxVal = toSize;

}

void orderBorders(QSize &minVal, QSize &maxVal)

{

    orderSizeBorders(minVal, maxVal);

}

void orderBorders(QSizeF &minVal, QSizeF &maxVal)

{

    orderSizeBorders(minVal, maxVal);

}

}

}

////////

template <class Value, class PrivateData>

static Value getData(const QMap<const QtProperty *, PrivateData> &propertyMap,

            Value PrivateData::*data,

            const QtProperty *property, const Value &defaultValue = Value())

{

    typedef QMap<const QtProperty *, PrivateData> PropertyToData;

    typedef Q_TYPENAME PropertyToData::const_iterator PropertyToDataConstIterator;

    const PropertyToDataConstIterator it = propertyMap.constFind(property);

    if (it == propertyMap.constEnd())

        return defaultValue;

    return it.value().*data;

}

template <class Value, class PrivateData>

static Value getValue(const QMap<const QtProperty *, PrivateData> &propertyMap,

            const QtProperty *property, const Value &defaultValue = Value())

{

    return getData<Value>(propertyMap, &PrivateData::val, property, defaultValue);

}

template <class Value, class PrivateData>

static Value getMinimum(const QMap<const QtProperty *, PrivateData> &propertyMap,

            const QtProperty *property, const Value &defaultValue = Value())

{

    return getData<Value>(propertyMap, &PrivateData::minVal, property, defaultValue);

}

template <class Value, class PrivateData>

static Value getMaximum(const QMap<const QtProperty *, PrivateData> &propertyMap,

            const QtProperty *property, const Value &defaultValue = Value())

{

    return getData<Value>(propertyMap, &PrivateData::maxVal, property, defaultValue);

}

template <class ValueChangeParameter, class Value, class PropertyManager>

static void setSimpleValue(QMap<const QtProperty *, Value> &propertyMap,

            PropertyManager *manager,

            void (PropertyManager::*propertyChangedSignal)(QtProperty *),

            void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),

            QtProperty *property, const Value &val)

{

    typedef QMap<const QtProperty *, Value> PropertyToData;

    typedef Q_TYPENAME PropertyToData::iterator PropertyToDataIterator;

    const PropertyToDataIterator it = propertyMap.find(property);

    if (it == propertyMap.end())

        return;

    if (it.value() == val)

        return;

    it.value() = val;

    emit (manager->*propertyChangedSignal)(property);

    emit (manager->*valueChangedSignal)(property, val);

}

template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value>

static void setValueInRange(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,

            void (PropertyManager::*propertyChangedSignal)(QtProperty *),

            void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),

            QtProperty *property, const Value &val,

            void (PropertyManagerPrivate::*setSubPropertyValue)(QtProperty *, ValueChangeParameter))

{

    typedef Q_TYPENAME PropertyManagerPrivate::Data PrivateData;

    typedef QMap<const QtProperty *, PrivateData> PropertyToData;

    typedef Q_TYPENAME PropertyToData::iterator PropertyToDataIterator;

    const PropertyToDataIterator it = managerPrivate->m_values.find(property);

    if (it == managerPrivate->m_values.end())

        return;

    PrivateData &data = it.value();

    if (data.val == val)

        return;

    const Value oldVal = data.val;

    data.val = qBound(data.minVal, val, data.maxVal);

    if (data.val == oldVal)

        return;

    if (setSubPropertyValue)

        (managerPrivate->*setSubPropertyValue)(property, data.val);

    emit (manager->*propertyChangedSignal)(property);

    emit (manager->*valueChangedSignal)(property, data.val);

}

template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value>

static void setBorderValues(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,

            void (PropertyManager::*propertyChangedSignal)(QtProperty *),

            void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),

            void (PropertyManager::*rangeChangedSignal)(QtProperty *, ValueChangeParameter, ValueChangeParameter),

            QtProperty *property, const Value &minVal, const Value &maxVal,

            void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,

                    ValueChangeParameter, ValueChangeParameter, ValueChangeParameter))

{

    typedef Q_TYPENAME PropertyManagerPrivate::Data PrivateData;

    typedef QMap<const QtProperty *, PrivateData> PropertyToData;

    typedef Q_TYPENAME PropertyToData::iterator PropertyToDataIterator;

    const PropertyToDataIterator it = managerPrivate->m_values.find(property);

    if (it == managerPrivate->m_values.end())

        return;

    Value fromVal = minVal;

    Value toVal = maxVal;

    orderBorders(fromVal, toVal);

    PrivateData &data = it.value();

    if (data.minVal == fromVal && data.maxVal == toVal)

        return;

    const Value oldVal = data.val;

    data.setMinimumValue(fromVal);

    data.setMaximumValue(toVal);

    emit (manager->*rangeChangedSignal)(property, data.minVal, data.maxVal);

    if (setSubPropertyRange)

        (managerPrivate->*setSubPropertyRange)(property, data.minVal, data.maxVal, data.val);

    if (data.val == oldVal)

        return;

    emit (manager->*propertyChangedSignal)(property);

    emit (manager->*valueChangedSignal)(property, data.val);

}

template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value, class PrivateData>

static void setBorderValue(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,

            void (PropertyManager::*propertyChangedSignal)(QtProperty *),

            void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),

            void (PropertyManager::*rangeChangedSignal)(QtProperty *, ValueChangeParameter, ValueChangeParameter),

            QtProperty *property,

            Value (PrivateData::*getRangeVal)() const,

            void (PrivateData::*setRangeVal)(ValueChangeParameter), const Value &borderVal,

            void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,

                    ValueChangeParameter, ValueChangeParameter, ValueChangeParameter))

{

    typedef QMap<const QtProperty *, PrivateData> PropertyToData;

    typedef Q_TYPENAME PropertyToData::iterator PropertyToDataIterator;

    const PropertyToDataIterator it = managerPrivate->m_values.find(property);

    if (it == managerPrivate->m_values.end())

        return;

    PrivateData &data = it.value();

    if ((data.*getRangeVal)() == borderVal)

        return;

    const Value oldVal = data.val;

    (data.*setRangeVal)(borderVal);

    emit (manager->*rangeChangedSignal)(property, data.minVal, data.maxVal);

    if (setSubPropertyRange)

        (managerPrivate->*setSubPropertyRange)(property, data.minVal, data.maxVal, data.val);

    if (data.val == oldVal)

        return;

    emit (manager->*propertyChangedSignal)(property);

    emit (manager->*valueChangedSignal)(property, data.val);

}

template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value, class PrivateData>

static void setMinimumValue(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,

            void (PropertyManager::*propertyChangedSignal)(QtProperty *),

            void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),

            void (PropertyManager::*rangeChangedSignal)(QtProperty *, ValueChangeParameter, ValueChangeParameter),

            QtProperty *property, const Value &minVal)

{

    void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,

                    ValueChangeParameter, ValueChangeParameter, ValueChangeParameter) = 0;

    setBorderValue<ValueChangeParameter, PropertyManagerPrivate, PropertyManager, Value, PrivateData>(manager, managerPrivate,

            propertyChangedSignal, valueChangedSignal, rangeChangedSignal,

            property, &PropertyManagerPrivate::Data::minimumValue, &PropertyManagerPrivate::Data::setMinimumValue, minVal, setSubPropertyRange);

}

template <class ValueChangeParameter, class PropertyManagerPrivate, class PropertyManager, class Value, class PrivateData>

static void setMaximumValue(PropertyManager *manager, PropertyManagerPrivate *managerPrivate,

            void (PropertyManager::*propertyChangedSignal)(QtProperty *),

            void (PropertyManager::*valueChangedSignal)(QtProperty *, ValueChangeParameter),

            void (PropertyManager::*rangeChangedSignal)(QtProperty *, ValueChangeParameter, ValueChangeParameter),

            QtProperty *property, const Value &maxVal)

{

    void (PropertyManagerPrivate::*setSubPropertyRange)(QtProperty *,

                    ValueChangeParameter, ValueChangeParameter, ValueChangeParameter) = 0;

    setBorderValue<ValueChangeParameter, PropertyManagerPrivate, PropertyManager, Value, PrivateData>(manager, managerPrivate,

            propertyChangedSignal, valueChangedSignal, rangeChangedSignal,

            property, &PropertyManagerPrivate::Data::maximumValue, &PropertyManagerPrivate::Data::setMaximumValue, maxVal, setSubPropertyRange);

}

class QtMetaEnumWrapper : public QObject

{

    Q_OBJECT

    Q_PROPERTY(QSizePolicy::Policy policy READ policy)

public:

    QSizePolicy::Policy policy() const { return QSizePolicy::Ignored; }

private:

    QtMetaEnumWrapper(QObject *parent) : QObject(parent) {}

};

class QtMetaEnumProvider

{

public:

    QtMetaEnumProvider();

    QStringList policyEnumNames() const { return m_policyEnumNames; }

    QStringList languageEnumNames() const { return m_languageEnumNames; }

    QStringList countryEnumNames(QLocale::Language language) const { return m_countryEnumNames.value(language); }

    QSizePolicy::Policy indexToSizePolicy(int index) const;

    int sizePolicyToIndex(QSizePolicy::Policy policy) const;

    void indexToLocale(int languageIndex, int countryIndex, QLocale::Language *language, QLocale::Country *country) const;

    void localeToIndex(QLocale::Language language, QLocale::Country country, int *languageIndex, int *countryIndex) const;

private:

    void initLocale();

    QStringList m_policyEnumNames;

    QStringList m_languageEnumNames;

    QMap<QLocale::Language, QStringList> m_countryEnumNames;

    QMap<int, QLocale::Language> m_indexToLanguage;

    QMap<QLocale::Language, int> m_languageToIndex;

    QMap<int, QMap<int, QLocale::Country> > m_indexToCountry;

    QMap<QLocale::Language, QMap<QLocale::Country, int> > m_countryToIndex;

    QMetaEnum m_policyEnum;

};

static QList<QLocale::Country> sortCountries(const QList<QLocale::Country> &countries)

{

    QMultiMap<QString, QLocale::Country> nameToCountry;

    QListIterator<QLocale::Country> itCountry(countries);

    while (itCountry.hasNext()) {

        QLocale::Country country = itCountry.next();

        nameToCountry.insert(QLocale::countryToString(country), country);

    }

    return nameToCountry.values();

}

void QtMetaEnumProvider::initLocale()

{

    QMultiMap<QString, QLocale::Language> nameToLanguage;

    QLocale::Language language = QLocale::C;

    while (language <= QLocale::LastLanguage) {

        QLocale locale(language);

        if (locale.language() == language)

            nameToLanguage.insert(QLocale::languageToString(language), language);

        language = (QLocale::Language)((uint)language + 1); // ++language

    }

    const QLocale system = QLocale::system();

    if (!nameToLanguage.contains(QLocale::languageToString(system.language())))

        nameToLanguage.insert(QLocale::languageToString(system.language()), system.language());

    QList<QLocale::Language> languages = nameToLanguage.values();

    QListIterator<QLocale::Language> itLang(languages);

    while (itLang.hasNext()) {

        QLocale::Language language = itLang.next();

        QList<QLocale::Country> countries;

        countries = QLocale::countriesForLanguage(language);

        if (countries.isEmpty() && language == system.language())

            countries << system.country();

        if (!countries.isEmpty() && !m_languageToIndex.contains(language)) {

            countries = sortCountries(countries);

            int langIdx = m_languageEnumNames.count();

            m_indexToLanguage[langIdx] = language;

            m_languageToIndex[language] = langIdx;

            QStringList countryNames;

            QListIterator<QLocale::Country> it(countries);

            int countryIdx = 0;

            while (it.hasNext()) {

                QLocale::Country country = it.next();

                countryNames << QLocale::countryToString(country);

                m_indexToCountry[langIdx][countryIdx] = country;

                m_countryToIndex[language][country] = countryIdx;

                ++countryIdx;

            }

            m_languageEnumNames << QLocale::languageToString(language);

            m_countryEnumNames[language] = countryNames;

        }

    }

}

QtMetaEnumProvider::QtMetaEnumProvider()

{

    QMetaProperty p;

    p = QtMetaEnumWrapper::staticMetaObject.property(

                QtMetaEnumWrapper::staticMetaObject.propertyOffset() + 0);

    m_policyEnum = p.enumerator();

    const int keyCount = m_policyEnum.keyCount();

    for (int i = 0; i < keyCount; i++)

        m_policyEnumNames << QLatin1String(m_policyEnum.key(i));

    initLocale();

}

QSizePolicy::Policy QtMetaEnumProvider::indexToSizePolicy(int index) const

{

    return static_cast<QSizePolicy::Policy>(m_policyEnum.value(index));

}

int QtMetaEnumProvider::sizePolicyToIndex(QSizePolicy::Policy policy) const

{

     const int keyCount = m_policyEnum.keyCount();

    for (int i = 0; i < keyCount; i++)

        if (indexToSizePolicy(i) == policy)

            return i;

    return -1;

}

void QtMetaEnumProvider::indexToLocale(int languageIndex, int countryIndex, QLocale::Language *language, QLocale::Country *country) const

{

    QLocale::Language l = QLocale::C;

    QLocale::Country c = QLocale::AnyCountry;

    if (m_indexToLanguage.contains(languageIndex)) {

        l = m_indexToLanguage[languageIndex];

        if (m_indexToCountry.contains(languageIndex) && m_indexToCountry[languageIndex].contains(countryIndex))

            c = m_indexToCountry[languageIndex][countryIndex];

    }

    if (language)

        *language = l;

    if (country)

        *country = c;

}

void QtMetaEnumProvider::localeToIndex(QLocale::Language language, QLocale::Country country, int *languageIndex, int *countryIndex) const

{

    int l = -1;

    int c = -1;

    if (m_languageToIndex.contains(language)) {

        l = m_languageToIndex[language];

        if (m_countryToIndex.contains(language) && m_countryToIndex[language].contains(country))

            c = m_countryToIndex[language][country];