From 8362bf63dea22bbf6736609b0f49c152f975eb63 Mon Sep 17 00:00:00 2001 From: tpearson Date: Wed, 20 Jan 2010 01:29:50 +0000 Subject: Added old abandoned KDE3 version of koffice git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1077364 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- lib/koproperty/set.cpp | 535 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 535 insertions(+) create mode 100644 lib/koproperty/set.cpp (limited to 'lib/koproperty/set.cpp') diff --git a/lib/koproperty/set.cpp b/lib/koproperty/set.cpp new file mode 100644 index 00000000..2e016b64 --- /dev/null +++ b/lib/koproperty/set.cpp @@ -0,0 +1,535 @@ +/* This file is part of the KDE project + Copyright (C) 2004 Cedric Pasteur + Copyright (C) 2004 Alexander Dymo + Copyright (C) 2004-2006 Jaroslaw Staniek + + 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 "set.h" +#include "property.h" +#include "utils.h" + +#include +#include +//#include + +#include +#include + +typedef QMap > StringListMap; +typedef QMapIterator StringListMapIterator; + +namespace KoProperty { + +//! @internal +static Property Set_nonConstNull; + +//! @internal +class SetPrivate +{ + public: + SetPrivate() : + dict(101, false), + readOnly(false), + informAboutClearing(0) + {} + ~SetPrivate(){} + + //dict of properties in form name: property + Property::Dict dict; +// PropertyList properties; + //groups of properties: + // list of group name: (list of property names) + StringListMap propertiesOfGroup; + QValueList groupNames; + QMap groupDescriptions; + QMap groupIcons; + // map of property: group + QMap groupForProperty; + + bool ownProperty : 1; + bool readOnly : 1; +// static Property nonConstNull; + QCString prevSelection; + QString typeName; + + //! Used in Set::informAboutClearing(Property*) to declare that the property wants + //! to be informed that the set has been cleared (all properties are deleted) + bool* informAboutClearing; + + inline KoProperty::Property& property(const QCString &name) const + { + KoProperty::Property *p = dict.find(name); + if (p) + return *p; + Set_nonConstNull.setName(0); //to ensure returned property is null + kopropertywarn << "Set::property(): PROPERTY \"" << name << "\" NOT FOUND" << endl; + return Set_nonConstNull; + } +}; + +} + +using namespace KoProperty; + +//Set::Iterator class +Set::Iterator::Iterator(const Set &set) +{ + iterator = new Property::DictIterator(set.d->dict); +} + +Set::Iterator::~Iterator() +{ + delete iterator; +} + +void +Set::Iterator::operator ++() +{ + ++(*iterator); +} + +Property* +Set::Iterator::operator *() const +{ + return current(); +} + +QCString +Set::Iterator::currentKey() const +{ + if (iterator) + return iterator->currentKey(); + + return QCString(); +} + +Property* +Set::Iterator::current() const +{ + if(iterator) + return iterator->current(); + + return 0; +} + +////////////////////////////////////////////// + +Set::Set(QObject *parent, const QString &typeName) +: QObject(parent, typeName.latin1()) +{ + d = new SetPrivate(); + d->ownProperty = true; + d->groupDescriptions.insert("common", i18n("General properties", "General")); + d->typeName = typeName; +} + + +Set::Set(const Set &set) + : QObject(0 /* implicit sharing the parent is dangerous */, set.name()) +{ + d = new SetPrivate(); + *this = set; +} + +Set::Set(bool propertyOwner) + : QObject(0, 0) +{ + d = new SetPrivate(); + d->ownProperty = propertyOwner; + d->groupDescriptions.insert("common", i18n("General properties", "General")); +} + +Set::~Set() +{ + emit aboutToBeCleared(); + emit aboutToBeDeleted(); + clear(); + delete d; +} + +///////////////////////////////////////////////////// + +void +Set::addPropertyInternal(Property *property, QCString group, bool updateSortingKey) +{ + if (group.isEmpty()) + group = "common"; + if (property == 0) { + kopropertywarn << "Set::addProperty(): property == 0" << endl; + return; + } + if (property->name().isEmpty()) { + kopropertywarn << "Set::addProperty(): COULD NOT ADD NULL PROPERTY" << endl; + return; + } + + Property *p = d->dict.find(property->name()); + if(p) { + p->addRelatedProperty(property); + } + else { + d->dict.insert(property->name(), property); + addToGroup(group, property); + } + + property->addSet(this); + if (updateSortingKey) + property->setSortingKey( d->dict.count() ); +} + +void +Set::addProperty(Property *property, QCString group) +{ + addPropertyInternal(property, group, true); +} + +void +Set::removeProperty(Property *property) +{ + if(!property) + return; + + Property *p = d->dict.take(property->name()); + removeFromGroup(p); + if(d->ownProperty) { + emit aboutToDeleteProperty(*this, *p); + delete p; + } +} + +void +Set::removeProperty(const QCString &name) +{ + if(name.isNull()) + return; + + Property *p = d->dict.find(name); + removeProperty(p); +} + +void +Set::clear() +{ + if (d->informAboutClearing) + *d->informAboutClearing = true; + d->informAboutClearing = 0; + aboutToBeCleared(); + d->propertiesOfGroup.clear(); + d->groupNames.clear(); + d->groupForProperty.clear(); + d->groupDescriptions.clear(); + d->groupIcons.clear(); + Property::DictIterator it(d->dict); + while (it.current()) + removeProperty( it.current() ); +} + +void +Set::informAboutClearing(bool& cleared) +{ + cleared = false; + d->informAboutClearing = &cleared; +} + +///////////////////////////////////////////////////// + +void +Set::addToGroup(const QCString &group, Property *property) +{ + if(!property) + return; + + //do not add the same property to the group twice + if(d->groupForProperty.contains(property) && (d->groupForProperty[property] == group)) + return; + + if(!d->propertiesOfGroup.contains(group)) { // group doesn't exist + QValueList l; + l.append(property->name()); + d->propertiesOfGroup.insert(group, l); + d->groupNames.append(group); + } + else { + d->propertiesOfGroup[group].append(property->name()); + } + d->groupForProperty.insert(property, group); +} + +void +Set::removeFromGroup(Property *property) +{ + if(!property) + return; + QCString group = d->groupForProperty[property]; + d->propertiesOfGroup[group].remove(property->name()); + if (d->propertiesOfGroup[group].isEmpty()) { + //remove group as well + d->propertiesOfGroup.remove(group); + QValueListIterator it = d->groupNames.find(group); + if (it != d->groupNames.end()) { + d->groupNames.remove(it); + } + } + d->groupForProperty.remove(property); +} + +const QValueList& +Set::groupNames() const +{ + return d->groupNames; +} + +const QValueList& +Set::propertyNamesForGroup(const QCString &group) const +{ + return d->propertiesOfGroup[group]; +} + +void +Set::setGroupDescription(const QCString &group, const QString& desc) +{ + d->groupDescriptions[group] = desc; +} + +QString +Set::groupDescription(const QCString &group) const +{ + if(d->groupDescriptions.contains(group)) + return d->groupDescriptions[group]; + return group; +} + +void +Set::setGroupIcon(const QCString &group, const QString& icon) +{ + d->groupIcons[group] = icon; +} + +QString +Set::groupIcon(const QCString &group) const +{ + return d->groupIcons[group]; +} + +///////////////////////////////////////////////////// + +uint +Set::count() const +{ + return d->dict.count(); +} + +bool +Set::isEmpty() const +{ + return d->dict.isEmpty(); +} + +bool +Set::isReadOnly() const +{ + return d->readOnly; +} + +void +Set::setReadOnly(bool readOnly) +{ + d->readOnly = readOnly; +} + +bool +Set::contains(const QCString &name) const +{ + return d->dict.find(name); +} + +Property& +Set::property(const QCString &name) const +{ + return d->property(name); +} + +Property& +Set::operator[](const QCString &name) const +{ + return d->property(name); +} + +const Set& +Set::operator= (const Set &set) +{ + if(&set == this) + return *this; + + clear(); + + d->ownProperty = set.d->ownProperty; + d->prevSelection = set.d->prevSelection; + d->groupDescriptions = set.d->groupDescriptions; + + // Copy all properties in the list + for(Property::DictIterator it(set.d->dict); it.current(); ++it) { + Property *prop = new Property( *it.current() ); + addPropertyInternal(prop, set.d->groupForProperty[ it.current() ], + false /*!updateSortingKey, because the key is already set in Property copy ctor.*/ ); + } + + return *this; +} + +void +Set::changeProperty(const QCString &property, const QVariant &value) +{ + Property *p = d->dict[property]; + if(p) + p->setValue(value); +} + +///////////////////////////////////////////////////// + +void +Set::debug() +{ + //kopropertydbg << "List: typeName='" << m_typeName << "'" << endl; + if(d->dict.isEmpty()) { + kopropertydbg << "" << endl; + return; + } + kopropertydbg << d->dict.count() << " properties:" << endl; + + for(Property::DictIterator it(d->dict); it.current(); ++it) + it.current()->debug(); +} + +QCString +Set::prevSelection() const +{ + return d->prevSelection; +} + +void +Set::setPrevSelection(const QCString &prevSelection) +{ + d->prevSelection = prevSelection; +} + +QString +Set::typeName() const +{ + return d->typeName; +} + +///////////////////////////////////////////////////// + +Buffer::Buffer() + :Set(false) +{ + connect( this, SIGNAL( propertyChanged( KoProperty::Set&, KoProperty::Property& ) ), + this, SLOT(intersectedChanged( KoProperty::Set&, KoProperty::Property& ) ) ); + + connect( this, SIGNAL( propertyReset( KoProperty::Set&, KoProperty::Property& ) ), + this, SLOT(intersectedReset( KoProperty::Set&, KoProperty::Property& ) ) ); +} + +Buffer::Buffer(const Set *set) + :Set(false) +{ + connect( this, SIGNAL( propertyChanged( KoProperty::Set&, KoProperty::Property& ) ), + this, SLOT(intersectedChanged( KoProperty::Set&, KoProperty::Property& ) ) ); + + connect( this, SIGNAL( propertyReset( KoProperty::Set&, KoProperty::Property& ) ), + this, SLOT(intersectedReset( KoProperty::Set&, KoProperty::Property& ) ) ); + + initialSet( set ); +} + +void Buffer::initialSet(const Set *set) +{ + //deep copy of set + for(Property::DictIterator it(set->d->dict); it.current(); ++it) { + Property *prop = new Property( *it.current() ); + QCString group = set->d->groupForProperty[it.current()]; + QString groupDesc = set->d->groupDescriptions[ group ]; + setGroupDescription( group, groupDesc ); + addProperty( prop, group ); + prop->addRelatedProperty( it.current() ); + } +} + +void Buffer::intersect(const Set *set) +{ + if ( d->dict.isEmpty() ) + { + initialSet( set ); + return; + } + + for(Property::DictIterator it(d->dict); it.current(); ++it) { + const char* key = it.current()->name(); + if ( Property *property = set->d->dict[ key ] ) + { + blockSignals( true ); + it.current()->resetValue(); + it.current()->addRelatedProperty( property ); + blockSignals( false ); + } + else + removeProperty( key ); + } +} + +void Buffer::intersectedChanged(KoProperty::Set& set, KoProperty::Property& prop) +{ + Q_UNUSED(set); + QCString propertyName = prop.name(); + if ( !contains( propertyName ) ) + return; + + const QValueList *props = prop.related(); + QValueList::const_iterator it = props->begin(); + for ( ; it != props->end(); ++it ) { + ( *it )->setValue( prop.value(), false ); + } +} + +void Buffer::intersectedReset(KoProperty::Set& set, KoProperty::Property& prop) +{ + Q_UNUSED(set); + QCString propertyName = prop.name(); + if ( !contains( propertyName ) ) + return; + + const QValueList *props = prop.related(); + QValueList::const_iterator it = props->begin(); + for ( ; it != props->end(); ++it ) { + ( *it )->setValue( prop.value(), false ); + } +} + +////////////////////////////////////////////// + +QMap KoProperty::propertyValues(const Set& set) +{ + QMap result; + for (Set::Iterator it(set); it.current(); ++it) + result.insert( it.currentKey(), it.current()->value() ); + + return result; +} + +#include "set.moc" -- cgit v1.2.1