File indexing completed on 2024-04-21 04:41:05

 /* This file is part of the KDE project
    Copyright (C) 2008-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 "KPropertyFactory.h"
 
 #include "KDefaultPropertyFactory.h"
 #include "KPropertyEditorView.h"
 #include "KPropertyStringEditor.h"
 #include "KPropertyUtils.h"
 #include "KPropertyUtils_p.h"
 
 class Q_DECL_HIDDEN KPropertyLabel::Private
 {
 public:
     Private()
     {
     }
     ~Private()
     {
     }
 
     const KProperty *property;
     const KPropertyValueDisplayInterface *iface;
     QVariant value;
 };
 
 KPropertyLabel::KPropertyLabel(QWidget *parent, const KProperty *property,
                                const KPropertyValueDisplayInterface *iface)
     : QLabel(parent), d(new Private)
 {
     d->property = property;
     d->iface = iface;
     setAutoFillBackground(true);
 
     KPropertyEditorView* view = nullptr;
     if (parent) {
         view = qobject_cast<KPropertyEditorView *>(parent->parentWidget());
     }
     const QColor gridLineColor(view ? view->gridLineColor()
                                     : KPropertyEditorView::defaultGridLineColor());
     const int top = 1 + (gridLineColor.isValid() ? 1 : 0);
 
     setContentsMargins(0, top, 0, 0);
     setIndent(1);
 }
 
 KPropertyLabel::~KPropertyLabel()
 {
     delete d;
 }
 
 QVariant KPropertyLabel::value() const
 {
     return d->value;
 }
 
 void KPropertyLabel::setValue(const QVariant& value)
 {
     d->value = value;
     setText(d->iface->propertyValueToString(d->property, QLocale()));
 }
 
 void KPropertyLabel::paintEvent( QPaintEvent * event )
 {
     QLabel::paintEvent(event);
     KPropertyWidgetsFactory::paintTopGridLine(this);
 }
 
 //---------------
 
 //! @internal
 class Q_DECL_HIDDEN KPropertyWidgetsFactory::Private
 {
 public:
     Private()
     {
     }
     ~Private()
     {
         qDeleteAll(editorCreatorsSet);
         qDeleteAll(valuePaintersSet);
     }
 
     QHash<int, KPropertyEditorCreatorInterface*> editorCreators;
     QHash<int, KPropertyValuePainterInterface*> valuePainters;
 
     QSet<KPropertyEditorCreatorInterface*> editorCreatorsSet;
     QSet<KPropertyValuePainterInterface*> valuePaintersSet;
 };
 
 KPropertyWidgetsFactory::KPropertyWidgetsFactory()
     : d( new Private )
 {
 }
 
 KPropertyWidgetsFactory::~KPropertyWidgetsFactory()
 {
     delete d;
 }
 
 QHash<int, KPropertyEditorCreatorInterface*> KPropertyWidgetsFactory::editorCreators() const
 {
     return d->editorCreators;
 }
 
 QHash<int, KPropertyValuePainterInterface*> KPropertyWidgetsFactory::valuePainters() const
 {
     return d->valuePainters;
 }
 
 void KPropertyWidgetsFactory::addEditor(int type, KPropertyEditorCreatorInterface *creator)
 {
     addEditorInternal( type, creator, true );
     if (dynamic_cast<KComposedPropertyCreatorInterface*>(creator)) {
         addComposedPropertyCreatorInternal( type,
             dynamic_cast<KComposedPropertyCreatorInterface*>(creator), false/* !own*/ );
     }
     if (dynamic_cast<KPropertyValuePainterInterface*>(creator)) {
         addPainterInternal( type, dynamic_cast<KPropertyValuePainterInterface*>(creator), false/* !own*/ );
     }
     if (dynamic_cast<KPropertyValueDisplayInterface*>(creator)) {
         addDisplayInternal( type, dynamic_cast<KPropertyValueDisplayInterface*>(creator), false/* !own*/ );
     }
 }
 
 void KPropertyWidgetsFactory::addPainter(int type, KPropertyValuePainterInterface *painter)
 {
     addPainterInternal(type, painter, true);
     if (dynamic_cast<KComposedPropertyCreatorInterface*>(painter)) {
         addComposedPropertyCreatorInternal( type,
         dynamic_cast<KComposedPropertyCreatorInterface*>(painter), false/* !own*/ );
     }
     if (dynamic_cast<KPropertyEditorCreatorInterface*>(painter)) {
         addEditorInternal( type, dynamic_cast<KPropertyEditorCreatorInterface*>(painter), false/* !own*/ );
     }
     if (dynamic_cast<KPropertyValueDisplayInterface*>(painter)) {
         addDisplayInternal( type, dynamic_cast<KPropertyValueDisplayInterface*>(painter), false/* !own*/ );
     }
 }
 
 void KPropertyWidgetsFactory::addEditorInternal(int type, KPropertyEditorCreatorInterface *editor, bool own)
 {
     if (own)
         d->editorCreatorsSet.insert(editor);
     d->editorCreators.insert(type, editor);
 }
 
 void KPropertyWidgetsFactory::addPainterInternal(int type, KPropertyValuePainterInterface *painter, bool own)
 {
     if (own)
         d->valuePaintersSet.insert(painter);
     d->valuePainters.insert(type, painter);
 }
 
 //static
 void KPropertyWidgetsFactory::paintTopGridLine(QWidget *widget)
 {
     // paint top grid line
     KPropertyEditorView* view = nullptr;
     if (widget->parentWidget()) {
         view = qobject_cast<KPropertyEditorView*>(widget->parentWidget()->parentWidget());
     }
     const QColor gridLineColor(view ? view->gridLineColor() : KPropertyEditorView::defaultGridLineColor());
     if (gridLineColor.isValid()) {
         const QAbstractScrollArea *area = qobject_cast<const QAbstractScrollArea*>(widget);
         QWidget *widgetToPaint;
         if (area && area->viewport()) {
             widgetToPaint = area->viewport();
         } else {
             widgetToPaint = widget;
         }
         QPainter p(widgetToPaint);
         p.setPen(QPen( QBrush(gridLineColor), 1));
         p.drawLine(0, 0, widget->width()-1, 0);
     }
 }
 
 //static
 void KPropertyWidgetsFactory::setTopAndBottomBordersUsingStyleSheet(QWidget *widget,
                                                                     const QString& extraStyleSheet)
 {
     KPropertyEditorView* view = nullptr;
     if (widget->parentWidget()) {
         view = qobject_cast<KPropertyEditorView*>(widget->parentWidget()->parentWidget());
     }
     const QColor gridLineColor(view ? view->gridLineColor() : KPropertyEditorView::defaultGridLineColor());
     widget->setStyleSheet(
         QString::fromLatin1("%1 { border-top: 1px solid %2;border-bottom: 1px solid %2; } %3")
         .arg(QLatin1String(widget->metaObject()->className()))
         .arg(gridLineColor.name()).arg(extraStyleSheet));
 }
 
 //------------
 
 class Q_DECL_HIDDEN KPropertyEditorCreatorOptions::Private
 {
 public:
     Private() : bordersVisible(false)
     {
     }
     Private(const Private &other) {
         copy(other);
     }
 #define KPropertyEditorCreatorOptionsPrivateArgs(o) std::tie(o.bordersVisible)
     void copy(const Private &other) {
         KPropertyEditorCreatorOptionsPrivateArgs((*this)) = KPropertyEditorCreatorOptionsPrivateArgs(other);
     }
     bool operator==(const Private &other) const {
         return KPropertyEditorCreatorOptionsPrivateArgs((*this)) == KPropertyEditorCreatorOptionsPrivateArgs(other);
     }
     bool bordersVisible;
 };
 
 KPropertyEditorCreatorOptions::KPropertyEditorCreatorOptions()
     : d(new Private)
 {
 }
 
 KPropertyEditorCreatorOptions::KPropertyEditorCreatorOptions(const KPropertyEditorCreatorOptions &other)
     : d(new Private(*other.d))
 {
 }
 
 KPropertyEditorCreatorOptions::~KPropertyEditorCreatorOptions()
 {
     delete d;
 }
 
 bool KPropertyEditorCreatorOptions::bordersVisible() const
 {
     return d->bordersVisible;
 }
 
 void KPropertyEditorCreatorOptions::setBordersVisible(bool visible)
 {
     d->bordersVisible = visible;
 }
 
 KPropertyEditorCreatorOptions& KPropertyEditorCreatorOptions::operator=(const KPropertyEditorCreatorOptions &other)
 {
     if (this != &other) {
         d->copy(*other.d);
     }
     return *this;
 }
 
 bool KPropertyEditorCreatorOptions::operator==(const KPropertyEditorCreatorOptions &other) const
 {
     return *d == *other.d;
 }
 
 //------------
 
 class Q_DECL_HIDDEN KPropertyEditorCreatorInterface::Private
 {
 public:
     Private()
     {
     }
 
     //! Options for altering the editor widget creation process
     KPropertyEditorCreatorOptions options;
 };
 
 KPropertyEditorCreatorInterface::KPropertyEditorCreatorInterface()
     : d(new Private)
 {
 }
 
 KPropertyEditorCreatorInterface::~KPropertyEditorCreatorInterface()
 {
     delete d;
 }
 
 QWidget* KPropertyEditorCreatorInterface::createEditor(int type, QWidget *parent,
                                                        const QStyleOptionViewItem & option,
                                                        const QModelIndex & index) const
 {
     Q_UNUSED(type);
     Q_UNUSED(option);
     Q_UNUSED(index);
     return new KPropertyStringEditor(parent);
 }
 
 const KPropertyEditorCreatorOptions* KPropertyEditorCreatorInterface::options() const
 {
     return &d->options;
 }
 
 KPropertyEditorCreatorOptions* KPropertyEditorCreatorInterface::options()
 {
     return &d->options;
 }
 
 //------------
 
 KPropertyValuePainterInterface::KPropertyValuePainterInterface()
 {
 }
 
 KPropertyValuePainterInterface::~KPropertyValuePainterInterface()
 {
 }
 
 //static
 void KPropertyValuePainterInterface::paint(const KPropertyValueDisplayInterface *iface,
                                            QPainter *painter, const QStyleOptionViewItem &option,
                                            const QModelIndex &index)
 {
     const KPropertyUtilsPrivate::PainterSaver saver(painter);
     QRect r(option.rect);
     r.setLeft(r.left() + 1);
     KProperty *prop = KPropertyUtils::propertyForIndex(index);
     painter->drawText(r, Qt::AlignLeft | Qt::AlignVCenter,
         iface->propertyValueToString(prop, QLocale()));
 }