Warning, file /libraries/kproperty/src/KProperty.cpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 /* This file is part of the KDE project
    Copyright (C) 2004 Cedric Pasteur <cedric.pasteur@free.fr>
    Copyright (C) 2004 Alexander Dymo <cloudtemple@mskat.net>
    Copyright (C) 2004-2017 Jarosław Staniek <staniek@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KProperty.h"
 #include "KPropertyFactory.h"
 #include "KPropertyListData.h"
 #include "KPropertySet_p.h"
 #include "KProperty_p.h"
 #include "kproperty_debug.h"
 
 #include <math.h>
 
 //! @return true if @a currentValue and @a value are compatible
 static bool compatibleTypes(const QVariant& currentValue, const QVariant &value)
 {
     if (currentValue.isNull() || value.isNull())
         return true;
     const QVariant::Type t = currentValue.type();
     const QVariant::Type newt = value.type();
     if (t == newt)
         return true;
     if (   (t == QVariant::Int && newt == QVariant::UInt)
         || (t == QVariant::UInt && newt == QVariant::Int)
         || (t == QVariant::ByteArray && newt == QVariant::String)
         || (t == QVariant::String && newt == QVariant::ByteArray)
         || (t == QVariant::ULongLong && newt == QVariant::LongLong)
         || (t == QVariant::LongLong && newt == QVariant::ULongLong))
     {
         return true;
     }
     return false;
 }
 
 // ----
 
 KProperty::Private::Private(KProperty *prop)
         : q(prop), type(KProperty::Auto), listData(nullptr), changed(false), storable(true),
         readOnly(false), visible(true),
         composed(nullptr), useComposedProperty(true),
         sets(nullptr), parent(nullptr), children(nullptr), relatedProperties(nullptr)
 {
 }
 
 void KProperty::Private::setCaptionForDisplaying(const QString& captionForDisplaying)
 {
     caption = captionForDisplaying.simplified();
     if (caption == captionForDisplaying) {
         caption.clear();
     }
     this->captionForDisplaying = captionForDisplaying;
 }
 
 KProperty::Private::~Private()
 {
     delete listData;
     if (children) {
         qDeleteAll(*children);
         delete children;
     }
     delete relatedProperties;
     delete composed;
     delete sets;
 }
 
 bool KProperty::Private::valueDiffersInternal(const QVariant &otherValue, KProperty::ValueOptions options)
 {
     if (!compatibleTypes(value, otherValue)) {
         kprWarning() << "INCOMPATIBLE TYPES! old=" << value << "new=" << otherValue << "in property" << q->name();
     }
 
     const QVariant::Type t = value.type();
     const QVariant::Type newt = otherValue.type();
     if (   t == QVariant::DateTime
         || t == QVariant::Time)
     {
         //for date and datetime types: compare with strings, because there
         //can be miliseconds difference
         return value.toString() != otherValue.toString();
     }
     else if (t == QVariant::String || t == QVariant::ByteArray) {
         //property is changed for string type,
         //if one of value is empty and other isn't..
         return (value.toString().isEmpty() != otherValue.toString().isEmpty())
               //..or both are not empty and values differ
               || (!value.toString().isEmpty() && !otherValue.toString().isEmpty() && value != otherValue);
     }
     else if (t == QVariant::Double) {
         const double factor = pow(10.0, option("precision", KPROPERTY_DEFAULT_DOUBLE_VALUE_PRECISION).toDouble());
         //kprDebug()
         //    << "factor:" << factor << "precision:" << option("precision", KPROPERTY_DEFAULT_DOUBLE_VALUE_STEP)
         //    << "double compared:" << value.toDouble() << otherValue.toDouble()
         //    << ":" << static_cast<qlonglong>(value.toDouble() * factor) << static_cast<qlonglong>(otherValue.toDouble() * factor);
         return static_cast<qlonglong>(value.toDouble() * factor) != static_cast<qlonglong>(otherValue.toDouble() * factor);
     } else if (t == QVariant::Invalid && newt == QVariant::Invalid) {
         return false;
     } else if (composed && !(options & ValueOption::IgnoreComposedProperty)) {
         return !composed->valuesEqual(value, otherValue);
     }
     else {
         return value != otherValue;
     }
 }
 
 bool KProperty::Private::setValueInternal(const QVariant &newValue, KProperty::ValueOptions valueOptions)
 {
     if (name.isEmpty()) {
         kprWarning() << "COULD NOT SET value to a null property";
         return false;
     }
 
     //1. Check if the value should be changed
     if (!valueDiffersInternal(newValue, valueOptions)) {
         return false;
     }
 
     //2. Then change it, and store old value if necessary
     if (valueOptions & KProperty::ValueOption::IgnoreOld) {
         oldValue = QVariant(); // clear old value
         changed = false;
     } else {
         if (!changed) {
             oldValue = value;
             changed = true;
         }
     }
     if (parent) {
         parent->d->childValueChanged(q, newValue, valueOptions);
     }
 
     QVariant prevValue;
     if (composed && useComposedProperty) {
         prevValue = value; //???
         composed->setChildValueChangedEnabled(false);
         composed->setValue(
             q, newValue, valueOptions | ValueOption::IgnoreComposedProperty // avoid infinite recursion
         );
         composed->setChildValueChangedEnabled(true);
     }
     else {
         prevValue = value;
     }
 
     value = newValue;
 
     if (!parent) { // emit only if parent has not done it
         emitPropertyChanged(); // called as last step in this method!
     }
     return true;
 }
 
 void KProperty::Private::addChild(KProperty *prop)
 {
     if (!prop) {
         return;
     }
 
     if (!children || std::find(children->begin(), children->end(), prop) == children->end()) { // not in our list
         if (!children) {
             children = new QList<KProperty*>();
         }
         children->append(prop);
         prop->d->parent = q;
     } else {
         kprWarning() << "property" << name
                    << ": child property" << prop->name() << "already added";
         return;
     }
 }
 
 void KProperty::Private::addSet(KPropertySet *newSet)
 {
     if (!newSet) {
         return;
     }
 
     if (!set) {//simple case
         set = newSet;
         return;
     }
     if (set == newSet || (sets && sets->contains(newSet))) {
         return;
     }
     if (!sets) {
         sets = new QList< QPointer<KPropertySet> >;
     }
     sets->append(QPointer<KPropertySet>(newSet));
 }
 
 void KProperty::Private::addRelatedProperty(KProperty *property)
 {
     if (!relatedProperties)
         relatedProperties = new QList<KProperty*>();
 
     if (!relatedProperties->contains(property)) {
         relatedProperties->append(property);
     }
 }
 
 void KProperty::Private::emitPropertyChanged()
 {
     QList< QPointer<KPropertySet> > *realSets = nullptr;
     if (sets) {
         realSets = sets;
     }
     else if (parent) {
         realSets = parent->d->sets;
     }
     if (realSets) {
         foreach (QPointer<KPropertySet> s, *realSets) {
             if (!s.isNull()) { //may be destroyed in the meantime
                 emit s->propertyChangedInternal(*s, *q);
                 emit s->propertyChanged(*s, *q);
             }
         }
     }
     else {
         QPointer<KPropertySet> realSet;
         if (set) {
             realSet = set;
         }
         else if (parent) {
             realSet = parent->d->set;
         }
         if (!realSet.isNull()) {
             //if the slot connect with that signal may call set->clear() - that's
             //the case e.g. at kexi/plugins/{macros|scripting}/* -  this KProperty
             //may got destroyed ( see KPropertySet::removeProperty(KProperty*) ) while we are
             //still on it. So, if we try to access ourself/this once the signal
             //got emitted we may end in a very hard to reproduce crash. So, the
             //emit should happen as last step in this method!
             emit realSet->propertyChangedInternal(*realSet, *q);
             emit realSet->propertyChanged(*realSet, *q);
         }
     }
 }
 
 void KProperty::Private::childValueChanged(KProperty *child, const QVariant &value,
                                            KProperty::ValueOptions valueOptions)
 {
     if (!composed) {
         return;
     }
     composed->childValueChangedInternal(
         child, value,
         valueOptions | KProperty::ValueOption::IgnoreComposedProperty // avoid infinite recursion
     );
 }
 
 /////////////////////////////////////////////////////////////////
 
 KProperty::KProperty(const QByteArray &name, const QVariant &value,
                    const QString &caption, const QString &description,
                    int type, KProperty* parent)
         : d(new KProperty::Private(this))
 {
     d->name = name;
     d->setCaptionForDisplaying(caption);
     d->description = description;
 
     if (type == int(Auto)) {
         type = value.type();
     }
     setType(type);
 
     if (parent)
         parent->d->addChild(this);
     setValue(value, ValueOption::IgnoreOld);
 }
 
 KProperty::KProperty(const QByteArray &name, KPropertyListData* listData,
                    const QVariant &value, const QString &caption, const QString &description,
                    int type, KProperty* parent)
         : d(new KProperty::Private(this))
 {
     d->name = name;
     d->setCaptionForDisplaying(caption);
     d->description = description;
     d->listData = listData;
     if (type == int(Auto)) {
         type = value.type();
     }
     setType(type);
 
     if (parent)
         parent->d->addChild(this);
     setValue(value, KProperty::ValueOption::IgnoreOld);
 }
 
 KProperty::KProperty()
         : d(new KProperty::Private(this))
 {
 }
 
 KProperty::KProperty(const KProperty &prop)
         : d(new KProperty::Private(this))
 {
     *this = prop;
 }
 
 KProperty::~KProperty()
 {
     delete d;
 }
 
 QByteArray
 KProperty::name() const
 {
     return d->name;
 }
 
 void
 KProperty::setName(const QByteArray &name)
 {
     d->name = name;
 }
 
 QString
 KProperty::caption() const
 {
     return d->caption.isEmpty() ? d->captionForDisplaying : d->caption;
 }
 
 QString
 KProperty::captionForDisplaying() const
 {
     return d->captionForDisplaying;
 }
 
 void
 KProperty::setCaption(const QString &caption)
 {
     d->setCaptionForDisplaying(caption);
 }
 
 QString
 KProperty::description() const
 {
     return d->description;
 }
 
 void
 KProperty::setDescription(const QString &desc)
 {
     d->description = desc;
 }
 
 int
 KProperty::type() const
 {
     return d->type;
 }
 
 void
 KProperty::setType(int type)
 {
     if (d->type != type) {
         d->type = type;
         delete d->composed;
         d->composed = KPropertyFactoryManager::self()->createComposedProperty(this);
     }
 }
 
 QString
 KProperty::iconName() const
 {
     return d->iconName;
 }
 
 void
 KProperty::setIconName(const QString &name)
 {
     d->iconName = name;
 }
 
 QVariant
 KProperty::value() const
 {
     return d->value;
 }
 
 QVariant
 KProperty::oldValue() const
 {
     return d->oldValue;
 }
 
 bool KProperty::setValue(const QVariant &value, ValueOptions options)
 {
     return d->setValueInternal(value, options);
 }
 
 void KProperty::setValue(const QVariant &value, bool doNotUseThisOverload, bool doNotUseThisOverload2)
 {
     Q_UNUSED(value);
     Q_UNUSED(doNotUseThisOverload);
     Q_UNUSED(doNotUseThisOverload2);
 }
 
 bool KProperty::valueEqualsTo(const QVariant &value, ValueOptions valueOptions) const
 {
     return !d->valueDiffersInternal(value, valueOptions);
 }
 
 void
 KProperty::resetValue()
 {
     if (!d->changed) {
         return;
     }
     d->changed = false;
     bool cleared = false;
     if (d->set) {
         KPropertySetPrivate::d(d->set)->informAboutClearing(&cleared); //inform me about possibly clearing the property sets
     }
     setValue(oldValue(), ValueOption::IgnoreOld);
     if (cleared)
         return; //property set has been cleared: no further actions make sense as 'this' is dead
 
     // maybe parent  prop is also unchanged now
     if (d->parent && d->parent->value() == d->parent->oldValue())
         d->parent->d->changed = false;
 
     if (d->sets) {
         foreach (QPointer<KPropertySet> set, *d->sets) {
             if (!set.isNull()) //may be destroyed in the meantime
                 emit set->propertyReset(*set, *this);
         }
     } else if (d->set) {
         emit d->set->propertyReset(*d->set, *this);
     }
 }
 
 KPropertyListData* KProperty::listData() const
 {
     return d->listData;
 }
 
 void
 KProperty::setListData(KPropertyListData* list)
 {
     if (list == d->listData)
         return;
     delete d->listData;
     d->listData = list;
 }
 
 void
 KProperty::setListData(const QStringList &keys, const QStringList &names)
 {
     KPropertyListData* list = new KPropertyListData(keys, names);
     setListData(list);
 }
 
 ////////////////////////////////////////////////////////////////
 
 bool
 KProperty::isNull() const
 {
     return d->name.isEmpty();
 }
 
 bool
 KProperty::isModified() const
 {
     if (d->changed) {
         return true;
     }
     if (d->children) {
         for (const KProperty* p : *d->children) {
             if (p->isModified()) {
                 return true;
             }
         }
     }
     return false;
 }
 
 void
 KProperty::clearModifiedFlag()
 {
     d->changed = false;
     if (d->children) {
         for (KProperty* p : *d->children) {
             p->clearModifiedFlag();
         }
     }
 }
 
 bool
 KProperty::isReadOnly() const
 {
     return d->readOnly;
 }
 
 void
 KProperty::setReadOnly(bool readOnly)
 {
     d->readOnly = readOnly;
 }
 
 bool
 KProperty::isVisible() const
 {
     return d->visible;
 }
 
 void
 KProperty::setVisible(bool visible)
 {
     d->visible = visible;
 }
 
 KProperty::ValueSyncPolicy KProperty::valueSyncPolicy() const
 {
     return d->valueSyncPolicy;
 }
 
 void
 KProperty::setValueSyncPolicy(KProperty::ValueSyncPolicy policy)
 {
     d->valueSyncPolicy = policy;
 }
 
 bool
 KProperty::isStorable() const
 {
     return d->storable;
 }
 
 void
 KProperty::setStorable(bool storable)
 {
     d->storable = storable;
 }
 
 void
 KProperty::setOption(const char* name, const QVariant& val)
 {
     if (val.isNull()) {
         d->options.remove(name);
     } else {
         d->options[name] = val;
     }
 }
 
 QVariant KProperty::option(const char* name, const QVariant& defaultValue) const
 {
     return d->option(name, defaultValue);
 }
 
 bool
 KProperty::hasOptions() const
 {
     return !d->options.isEmpty() || (d->parent && d->parent->hasOptions());
 }
 
 /////////////////////////////////////////////////////////////////
 
 KProperty&
 KProperty::operator= (const QVariant & val)
 {
     setValue(val);
     return *this;
 }
 
 KProperty&
 KProperty::operator= (const KProperty & property)
 {
     if (&property == this)
         return *this;
 
     delete d->listData;
     d->listData = nullptr;
     delete d->children;
     d->children = nullptr;
     delete d->relatedProperties;
     d->relatedProperties = nullptr;
     delete d->composed;
     d->composed = nullptr;
 
     d->name = property.d->name;
     d->setCaptionForDisplaying(property.captionForDisplaying());
     d->description = property.d->description;
     d->type = property.d->type;
 
     d->iconName = property.d->iconName;
     d->valueSyncPolicy = property.d->valueSyncPolicy;
     d->visible = property.d->visible;
     d->storable = property.d->storable;
     d->readOnly = property.d->readOnly;
     d->options = property.d->options;
 
     if (property.d->listData) {
         d->listData = new KPropertyListData(*property.d->listData);
     }
     if (property.d->composed) {
         delete d->composed;
         d->composed = KPropertyFactoryManager::self()->createComposedProperty(this);
         // updates all children value, using KComposedPropertyInterface
         setValue(property.value());
     } else {
         d->value = property.d->value;
         if (property.d->children) {
             // no KComposedPropertyInterface (should never happen), simply copy all children
             d->children = new QList<KProperty*>();
             QList<KProperty*>::ConstIterator endIt = property.d->children->constEnd();
             for (QList<KProperty*>::ConstIterator it = property.d->children->constBegin(); it != endIt; ++it) {
                 KProperty *child = new KProperty(*(*it));
                 d->addChild(child);
             }
         }
     }
 
     if (property.d->relatedProperties) {
         d->relatedProperties = new QList<KProperty*>(*(property.d->relatedProperties));
     }
 
     // update these later because they may have been changed when creating children
     d->oldValue = property.d->oldValue;
     d->changed = property.d->changed;
     return *this;
 }
 
 bool
 KProperty::operator ==(const KProperty &prop) const
 {
     return ((d->name == prop.d->name) && (value() == prop.value()));
 }
 
 bool KProperty::operator!=(const KProperty &prop) const
 {
     return !operator==(prop);
 }
 
 /////////////////////////////////////////////////////////////////
 
 const QList<KProperty*>*
 KProperty::children() const
 {
     return d->children;
 }
 
 KProperty*
 KProperty::child(const QByteArray &name)
 {
     QList<KProperty*>::ConstIterator endIt = d->children->constEnd();
     for (QList<KProperty*>::ConstIterator it = d->children->constBegin(); it != endIt; ++it) {
         if ((*it)->name() == name)
             return *it;
     }
     return nullptr;
 }
 
 KProperty*
 KProperty::parent() const
 {
     return d->parent;
 }
 
 KComposedPropertyInterface* KProperty::composedProperty() const
 {
     return d->composed;
 }
 
 void
 KProperty::setComposedProperty(KComposedPropertyInterface *prop)
 {
     if (d->composed == prop)
         return;
     delete d->composed;
     d->composed = prop;
 }
 
 #if 0
 int Property::sortingKey() const
 {
     return d->sortingKey;
 }
 
 void Property::setSortingKey(int key)
 {
     d->sortingKey = key;
 }
 #endif
 
 /////////////////////////////////////////////////////////////////
 
 KPROPERTYCORE_EXPORT QDebug operator<<(QDebug dbg, const KProperty &p)
 {
     dbg.nospace() << "KProperty("
         << "NAME=" << p.name();
     if (!p.captionForDisplaying().isEmpty()) {
         dbg.nospace() << " CAPTION_FOR_DISPLAYING=" << p.captionForDisplaying();
         if (p.captionForDisplaying() != p.caption()) {
             dbg.nospace() << " CAPTION=" << p.caption();
         }
     }
     if (!p.description().isEmpty()) {
         dbg.nospace() << " DESC=" << p.description();
     }
     dbg.nospace() << " TYPE=" << p.type();
     if (p.value().isValid()) {
         dbg.nospace() << " VALUE=" << p.value();
     }
     else {
         dbg.nospace() << " VALUE=<INVALID>";
     }
     if (p.oldValue().isValid()) {
         dbg.nospace() << " OLDVALUE=" << p.oldValue();
     }
     if (p.isModified()) {
         dbg.nospace() << " MODIFIED";
     }
     if (!p.isVisible()) {
         dbg.nospace() << " HIDDEN";
     }
 
 //! @todo children...
 
     if (p.hasOptions()) {
         dbg.nospace() << " OPTIONS(" << p.d->options.count() << "): [";
         QList<QByteArray> optionKeys( p.d->options.keys() );
         std::sort(optionKeys.begin(), optionKeys.end());
         bool first = true;
         foreach (const QByteArray& key, optionKeys) {
             if (first) {
                 first = false;
             }
             else {
                 dbg.space() << ",";
             }
             dbg.nospace() << key << ":" << p.option(key.constData());
         }
         dbg.nospace() << "]";
     }
 
     dbg.nospace() << ")";
     return dbg.space();
 }