File indexing completed on 2024-05-12 16:39:51

 /* This file is part of the KDE project
    Copyright (C) 2003 Lucijan Busch <lucijan@gmx.at>
    Copyright (C) 2004 Cedric Pasteur <cedric.pasteur@free.fr>
    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 "WidgetInfo.h"
 #include "widgetfactory.h"
 
 #include <KDb>
 
 #include <KProperty>
 
 #include <KLocalizedString>
 
 namespace KFormDesigner {
 class Q_DECL_HIDDEN WidgetInfo::Private
 {
 public:
     Private (WidgetFactory *f)
         : overriddenAlternateNames(0)
         , factory(f)
         , propertiesWithDisabledAutoSync(0)
         , customTypesForProperty(0)
         , inheritedClass(0)
     {
     }
 
     ~Private() {
         delete overriddenAlternateNames;
         delete propertiesWithDisabledAutoSync;
         delete customTypesForProperty;
     }
 
     QString iconName;
     QByteArray className;
     QString name;
     QByteArray namePrefix;
     QString translatedNamePrefix;
     QString desc;
     QString include;
     QList<QByteArray> alternateNames;
     QList<QByteArray> *overriddenAlternateNames;
     QList<QByteArray> autoSaveProperties;
     QByteArray saveName;
     QPointer<WidgetFactory> factory;
     QHash<QByteArray, tristate> *propertiesWithDisabledAutoSync;
     QHash<QByteArray, int> *customTypesForProperty;
     QByteArray parentFactoryName;
     QByteArray inheritedClassName; //!< Used for inheriting widgets between factories
     WidgetInfo* inheritedClass;
     Qt::Alignment supportedAlignmentFlags = Qt::Alignment(Qt::AlignHorizontal_Mask | Qt::AlignVertical_Mask) ^ Qt::AlignAbsolute;
 };
 }
 
 //--------------------------------------
 
 using namespace KFormDesigner;
 
 WidgetInfo::WidgetInfo(WidgetFactory *f)
  : d(new Private(f) )
 {
 }
 
 WidgetInfo::~WidgetInfo()
 {
     delete d;
 }
 
 QString WidgetInfo::iconName() const
 {
     return d->iconName;
 }
 
 void WidgetInfo::setIconName(const QString &iconName)
 {
     d->iconName = iconName;
 }
 
 QByteArray WidgetInfo::className() const
 {
     return d->className;
 }
 
 void WidgetInfo::setClassName(const QByteArray &className)
 {
     d->className = className;
 }
 
 QByteArray WidgetInfo::inheritedClassName() const
 {
     return d->inheritedClassName;
 }
 
 void WidgetInfo::setInheritedClassName(const QByteArray& inheritedClassName)
 {
     d->inheritedClassName = inheritedClassName;
     if (d->className.isEmpty())
         d->className = inheritedClassName; // the default
 }
 
 void WidgetInfo::setInheritedClass(WidgetInfo *inheritedClass)
 {
     d->inheritedClass = inheritedClass;
 }
 
 WidgetInfo* WidgetInfo::inheritedClass() const
 {
     return d->inheritedClass;
 }
 
 QString WidgetInfo::namePrefix() const
 {
     return QString::fromLatin1(d->namePrefix);
 }
 
 QString WidgetInfo::translatedNamePrefix() const
 {
     return d->translatedNamePrefix;
 }
 
 void WidgetInfo::setNamePrefix(const char *context, const char *prefix)
 {
     Q_UNUSED(context)
     d->namePrefix = prefix;
     if (!KDb::isIdentifier(d->namePrefix)) {
         qWarning() << "Invalid untranslated name prefix" << d->namePrefix
                    << "for form widgets of class" << className()
                    << "has been detected. It is not a valid identifier. \"widget\" prefix"
                    << "will be used. Please report the issue to authors of the" << className()
                    << "class implementation so they can fix it.";
         d->namePrefix = "widget";
         d->translatedNamePrefix = d->namePrefix;
         return;
     }
     // Proper prefix, but is it translated properly?
     const QString newTranslatedNamePrefix = i18n(d->namePrefix);
     if (KDb::isIdentifier(newTranslatedNamePrefix)) {
         d->translatedNamePrefix = newTranslatedNamePrefix;
     } else {
         qWarning() << "Invalid translation" << newTranslatedNamePrefix
                    << "of name prefix" << d->namePrefix << "for form widgets of class" << className()
                    << "has been detected. It is not a valid identifier. Untranslated prefix"
                    << d->namePrefix << "will be used. Please report the issue to authors of"
                    << QLocale().name() << "translation so they can fix it.";
         d->translatedNamePrefix = d->namePrefix;
     }
 }
 
 QString WidgetInfo::name() const
 {
     return d->name;
 }
 
 void WidgetInfo::setName(const QString &n)
 {
     d->name = n;
 }
 
 QString WidgetInfo::description() const
 {
     return d->desc;
 }
 
 
 void WidgetInfo::setDescription(const QString &desc)
 {
     d->desc = desc;
 }
 
 QString WidgetInfo::includeFileName() const
 {
     return d->include;
 }
 
 void WidgetInfo::setIncludeFileName(const QString &name)
 {
     d->include = name;
 }
 
 QList<QByteArray> WidgetInfo::alternateClassNames() const
 {
     return d->alternateNames;
 }
 
 QByteArray WidgetInfo::savingName() const
 {
     return d->saveName;
 }
 
 WidgetFactory* WidgetInfo::factory() const
 {
     return d->factory;
 }
 
 void WidgetInfo::setSavingName(const QByteArray& saveName)
 {
     d->saveName = saveName;
 }
 
 QByteArray WidgetInfo::parentFactoryName() const
 {
     return d->parentFactoryName;
 }
 
 void WidgetInfo::setParentFactoryName(const QByteArray& parentFactoryName)
 {
     d->parentFactoryName = parentFactoryName;
 }
 
 void WidgetInfo::addAlternateClassName(const QByteArray& alternateName, bool override)
 {
     d->alternateNames += alternateName;
     if (override) {
         if (!d->overriddenAlternateNames)
             d->overriddenAlternateNames = new QList<QByteArray>;
         d->overriddenAlternateNames->append(alternateName);
     } else {
         if (d->overriddenAlternateNames)
             d->overriddenAlternateNames->removeAll(alternateName);
     }
 }
 
 bool WidgetInfo::isOverriddenClassName(const QByteArray& alternateName) const
 {
     return d->overriddenAlternateNames && d->overriddenAlternateNames->contains(alternateName);
 }
 
 void WidgetInfo::setAutoSyncForProperty(const QByteArray& propertyName, tristate flag)
 {
     if (!d->propertiesWithDisabledAutoSync) {
         if (~flag)
             return;
         d->propertiesWithDisabledAutoSync = new QHash<QByteArray, tristate>;
     }
 
     if (~flag) {
         d->propertiesWithDisabledAutoSync->remove(propertyName);
     } else {
         d->propertiesWithDisabledAutoSync->insert(propertyName, flag);
     }
 }
 
 tristate WidgetInfo::autoSyncForProperty(const QByteArray& propertyName) const
 {
     if (!d->propertiesWithDisabledAutoSync)
         return cancelled;
     tristate flag = d->propertiesWithDisabledAutoSync->value(propertyName);
     return flag;
 }
 
 void WidgetInfo::setAutoSaveProperties(const QList<QByteArray>& properties)
 {
     d->autoSaveProperties = properties;
 }
 
 QList<QByteArray> WidgetInfo::autoSaveProperties() const
 {
     if (!d->inheritedClass)
         return d->autoSaveProperties;
     return d->inheritedClass->autoSaveProperties() + d->autoSaveProperties;
 }
 
 void WidgetInfo::setCustomTypeForProperty(const QByteArray& propertyName, int type)
 {
     if (propertyName.isEmpty() || type == int(KProperty::Auto))
         return;
     if (!d->customTypesForProperty) {
         d->customTypesForProperty = new QHash<QByteArray, int>();
     }
     d->customTypesForProperty->remove(propertyName);
     d->customTypesForProperty->insert(propertyName, type);
 }
 
 int WidgetInfo::customTypeForProperty(const QByteArray& propertyName) const
 {
     if (!d->customTypesForProperty || !d->customTypesForProperty->contains(propertyName))
         return KProperty::Auto;
     return d->customTypesForProperty->value(propertyName);
 }
 
 QVariant WidgetInfo::internalProperty(const QByteArray& property) const
 {
     return d->factory->internalProperty(d->className, property);
 }
 
 void WidgetInfo::setInternalProperty(const QByteArray& property, const QVariant& value)
 {
     InternalPropertyHandlerInterface *iface = static_cast<InternalPropertyHandlerInterface*>(d->factory);
     iface->setInternalProperty(d->className, property, value);
 }
 
 Qt::Alignment WidgetInfo::supportedAlignmentFlags() const
 {
     return d->supportedAlignmentFlags;
 }
 
 void WidgetInfo::setSupportedAlignmentFlags(Qt::Alignment flags)
 {
     d->supportedAlignmentFlags = flags;
 }