File indexing completed on 2024-04-21 15:30:31

 /* This file is part of the KDE project
    Copyright (C) 2008-2018 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 "KPropertyEditorView.h"
 #include "KPropertyEditorDataModel_p.h"
 #include "KProperty.h"
 #include "KPropertySet.h"
 #include "KPropertyWidgetsFactory.h"
 #include "KPropertyWidgetsPluginManager.h"
 #include "kproperty_debug.h"
 #include "KPropertyUtils.h"
 #include "KPropertyUtils_p.h"
 
 #include <QIcon>
 #include <QPointer>
 #include <QItemDelegate>
 #include <QPainter>
 #include <QMouseEvent>
 #include <QToolTip>
 #include <QApplication>
 #include <QHeaderView>
 #include <QLineEdit>
 
 #if 0 // not sure if we should use it, better to fix Oxygen?
 #include <kexiutils/styleproxy.h>
 
 //! Used to alter the widget's style at design time
 class EditorViewStyle : public KexiUtils::StyleProxy
 {
 public:
     explicit EditorViewStyle(QStyle* parentStyle) : KexiUtils::StyleProxy(parentStyle)
     {
     }
 
     virtual void drawPrimitive(PrimitiveElement elem, const QStyleOption* option,
         QPainter* painter, const QWidget* widget) const
     {
 /*        if (elem == PE_PanelLineEdit) {
             const QStyleOptionFrame *panel = qstyleoption_cast<const QStyleOptionFrame*>(option);
             if (panel) {
                 QStyleOptionFrame alteredOption(*panel);
                 alteredOption.lineWidth = 0;
                 KexiUtils::StyleProxy::drawPrimitive(elem, &alteredOption,
                     painter, widget);
                 return;
             }
         }*/
         KexiUtils::StyleProxy::drawPrimitive(elem, option,
             painter, widget);
     }
 };
 #endif
 
 static bool effectiveValueSyncPolicy(const KProperty *property, bool defaultValue)
 {
     if (property->valueSyncPolicy() == KProperty::ValueSyncPolicy::Editor) {
         return defaultValue;
     }
     return property->valueSyncPolicy() == KProperty::ValueSyncPolicy::Auto;
 }
 
 //----------
 
 class ItemDelegate : public QItemDelegate
 {
 public:
     explicit ItemDelegate(KPropertyEditorView *parent);
     ~ItemDelegate() override;
     void paint(QPainter *painter,
         const QStyleOptionViewItem &option, const QModelIndex &index) const override;
     QSize sizeHint(const QStyleOptionViewItem &option,
         const QModelIndex &index) const override;
     QWidget * createEditor(QWidget *parent,
         const QStyleOptionViewItem &option, const QModelIndex &index) const override;
     mutable QPointer<QWidget> m_currentEditor;
 };
 
 ItemDelegate::ItemDelegate(KPropertyEditorView *parent)
 : QItemDelegate(parent)
 {
 }
 
 ItemDelegate::~ItemDelegate()
 {
 }
 
 static int getIconSize(int fontPixelSize)
 {
     return fontPixelSize * 0.85;
 }
 
 static int typeForProperty(const KProperty* prop)
 {
     if (prop->listData())
         return KProperty::ValueFromList;
     else
         return prop->type();
 }
 
 void ItemDelegate::paint(QPainter *painter,
                          const QStyleOptionViewItem &option,
                          const QModelIndex &index) const
 {
     QStyleOptionViewItem alteredOption(option);
     const KPropertyUtilsPrivate::PainterSaver saver(painter);
     const KPropertyEditorDataModel *editorModel = qobject_cast<const KPropertyEditorDataModel*>(index.model());
     if (!editorModel) {
         return;
     }
 
     QRect r(option.rect);
     bool modified = false;
     const QColor gridLineColor(qobject_cast<KPropertyEditorView*>(parent())->gridLineColor());
     if (gridLineColor.isValid()) {
         alteredOption.rect.setTop(alteredOption.rect.top() + 1);
     }
     if (index.column()==0) {
         r.setWidth(r.width() - 1);
         r.setLeft(-1); // to avoid displaying double left border
 
         QVariant modifiedVariant( editorModel->data(index, KPropertyEditorDataModel::PropertyModifiedRole) );
         if (modifiedVariant.isValid() && modifiedVariant.toBool()) {
             modified = true;
             QFont font(alteredOption.font);
             font.setBold(true);
             alteredOption.font = font;
         }
     }
     else {
         r.setLeft(r.left()-1);
     }
     const int x2 = alteredOption.rect.right();
     const int y2 = alteredOption.rect.bottom();
     const int iconSize = getIconSize( alteredOption.font.pixelSize() );
     if (modified) {
         alteredOption.rect.setRight( alteredOption.rect.right() - iconSize * 1 );
     }
 
     const bool isGroupHeader(editorModel->data(index, KPropertyEditorDataModel::PropertyGroupRole).toBool());
     if (!isGroupHeader) {
         KProperty *property = editorModel->propertyForIndex(index);
         const int t = typeForProperty( property );
         bool useQItemDelegatePaint = true; // ValueDisplayInterface is used by default
         if (index.column() == 1 && KPropertyWidgetsPluginManager::self()->paint(t, painter, alteredOption, index)) {
             useQItemDelegatePaint = false;
         }
         if (useQItemDelegatePaint) {
             QItemDelegate::paint(painter, alteredOption, index);
         }
 
         if (modified) {
             alteredOption.rect.setRight( alteredOption.rect.right() - iconSize * 3 / 2 );
             int y1 = alteredOption.rect.top();
             QLinearGradient grad(x2 - iconSize * 2, y1, x2 - iconSize / 2, y1);
             QColor color(
                 alteredOption.palette.color(
                     (alteredOption.state & QStyle::State_Selected) ? QPalette::Highlight : QPalette::Base ));
             color.setAlpha(0);
             grad.setColorAt(0.0, color);
             color.setAlpha(255);
             grad.setColorAt(0.5, color);
             QBrush gradBrush(grad);
             painter->fillRect(x2 - iconSize * 2, y1, iconSize * 2, y2 - y1 + 1, gradBrush);
 
             //!TODO
             //QPixmap revertIcon(QIcon::fromTheme(QLatin1String("edit-undo")).pixmap(iconSize, iconSize));
             //revertIcon = KIconEffect().apply(revertIcon, KIconEffect::Colorize, 1.0,
             //    alteredOption.palette.color(
             //        (alteredOption.state & QStyle::State_Selected) ? QPalette::HighlightedText : QPalette::Text ), false);
             //painter->drawPixmap( x2 - iconSize - 2,
             //   y1 + 1 + (alteredOption.rect.height() - revertIcon.height()) / 2, revertIcon);
         }
     }
 
     if (gridLineColor.isValid()) {
         QPen pen(gridLineColor);
         painter->setPen(pen);
         painter->drawLine(r.topLeft(), r.topRight() + QPoint(1, 0));
         painter->drawLine(r.bottomLeft() + QPoint(0, 1), r.bottomRight() + QPoint(1, 1));
         if (!isGroupHeader) {
             painter->drawLine(r.topRight() + QPoint(1, 0), r.bottomRight() + QPoint(1, 1));
             painter->drawLine(r.topLeft(), r.bottomLeft() + QPoint(0, 1));
         }
     }
     else {
         QPen pen(alteredOption.palette.color(QPalette::AlternateBase));
         painter->setPen(pen);
         painter->drawLine(r.topLeft(), r.topRight());
     }
     //kprDebug()<<"rect:" << r << "viewport:" << painter->viewport() << "window:"<<painter->window();
 }
 
 QSize ItemDelegate::sizeHint(const QStyleOptionViewItem &option,
                              const QModelIndex &index) const
 {
     QStyleOptionViewItem realOption(option);
     if (index.column() == 0) {
         // Measure for bold font because it might be used at any time if the property value is modified
         realOption.font.setBold(true);
     }
     return QItemDelegate::sizeHint(realOption, index) + QSize(0, 2);
 }
 
 QWidget * ItemDelegate::createEditor(QWidget * parent,
     const QStyleOptionViewItem & option, const QModelIndex & index ) const
 {
     if (!index.isValid())
         return nullptr;
     const KProperty *property = KPropertyUtils::propertyForIndex(index);
     if (property && property->isReadOnly()) {
         return nullptr;
     }
     const int t = property ? typeForProperty(property) : KProperty::String;
     QStyleOptionViewItem alteredOption(option);
     alteredOption.rect.setHeight(alteredOption.rect.height()+3);
     QWidget *w = KPropertyWidgetsPluginManager::self()->createEditor(t, parent, alteredOption, index);
     if (!w) {
         // fall back to String type
         w = KPropertyWidgetsPluginManager::self()->createEditor(KProperty::String, parent, alteredOption, index);
     }
     if (w) {
         if (-1 != w->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("commitData(QWidget*)").constData())
             && property && !property->children())
         {
         }
     }
     else {
         w = QItemDelegate::createEditor(parent, alteredOption, index);
     }
     QObject::disconnect(w, SIGNAL(commitData(QWidget*)),
         this, SIGNAL(commitData(QWidget*)));
     if (property && effectiveValueSyncPolicy(property,
             qobject_cast<KPropertyEditorView*>(this->parent())->isValueSyncEnabled()))
     {
         QObject::connect(w, SIGNAL(commitData(QWidget*)),
             this, SIGNAL(commitData(QWidget*)), Qt::UniqueConnection);
     }
     m_currentEditor = w;
     return w;
 }
 
 //----------
 
 class Q_DECL_HIDDEN KPropertyEditorView::Private
 {
 public:
     explicit Private(KPropertyEditorView *view)
      : model(nullptr)
      , gridLineColor( KPropertyEditorView::defaultGridLineColor() )
      , valueSync(true)
      , slotPropertyChangedEnabled(true)
      , q(view)
     {
     }
 
     //! Expands group and parent property items if needed (based on settings)
     void expandIfNeeded() {
         if (!model) {
             return;
         }
         const int rowCount = model->rowCount();
         for (int row = 0; row < rowCount; row++) {
             expandChildItemsIfNeeded(model->index(row, 0));
         }
     }
 
     //! Expands property child items in a subtree recursively if needed (based on settings)
     void expandChildItemsIfNeeded(const QModelIndex &parent) {
         if (!model) {
             return;
         }
         const bool isGroupHeader(model->data(parent, KPropertyEditorDataModel::PropertyGroupRole).toBool());
         if (isGroupHeader) {
             if (groupItemsExpanded) {
                 q->expand(parent);
             }
         } else {
             if (childPropertyItemsExpanded) {
                 q->expand(parent);
             }
         }
         const int rowCount = model->rowCount(parent);
         for (int row = 0; row < rowCount; row++) {
             const QModelIndex child(model->index(row, 0, parent));
             expandChildItemsIfNeeded(child);
         }
     }
 
     QPointer<KPropertySet> set;
     KPropertyEditorDataModel *model;
     ItemDelegate *itemDelegate;
     QColor gridLineColor;
     bool valueSync;
     bool slotPropertyChangedEnabled;
     bool childPropertyItemsExpanded = true;
     bool groupItemsExpanded = true;
     bool groupsVisible = true;
     bool toolTipsVisible = false;
 
 private:
     KPropertyEditorView * const q;
 };
 
 KPropertyEditorView::KPropertyEditorView(QWidget* parent)
         : QTreeView(parent)
         , d(new Private(this))
 {
     setObjectName(QLatin1String("KPropertyEditorView"));
     setAlternatingRowColors(true);
     setSelectionBehavior(QAbstractItemView::SelectRows);
     setSelectionMode(QAbstractItemView::SingleSelection);
     setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
     setAnimated(false);
     setAllColumnsShowFocus(true);
     header()->setSectionsMovable(false);
 
     setEditTriggers(
           QAbstractItemView::CurrentChanged
         | QAbstractItemView::DoubleClicked
         | QAbstractItemView::EditKeyPressed
         | QAbstractItemView::AnyKeyPressed
         | QAbstractItemView::AllEditTriggers);
 
     setItemDelegate(d->itemDelegate = new ItemDelegate(this));
 }
 
 KPropertyEditorView::~KPropertyEditorView()
 {
     delete d;
 }
 
 void KPropertyEditorView::changeSet(KPropertySet *set, SetOptions options)
 {
     changeSetInternal(set, options, QByteArray());
 }
 
 void KPropertyEditorView::changeSet(KPropertySet *set, const QByteArray& propertyToSelect, SetOptions options)
 {
     changeSetInternal(set, options, propertyToSelect);
 }
 
 void KPropertyEditorView::changeSetInternal(KPropertySet *set, SetOptions options,
     const QByteArray& propertyToSelect)
 {
 //! @todo port??
 #if 0
     if (d->insideSlotValueChanged) {
         //changeSet() called from inside of slotValueChanged()
         //this is dangerous, because there can be pending events,
         //especially for the GUI stuff, so let's do delayed work
         d->setListLater_list = set;
         d->preservePrevSelection_preservePrevSelection = preservePrevSelection;
         d->preservePrevSelection_propertyToSelect = propertyToSelect;
         qApp->processEvents(QEventLoop::AllEvents);
         if (d->set) {
             //store prev. selection for this prop set
             if (d->currentItem)
                 d->set->setPrevSelection(d->currentItem->property()->name());
             kprDebug() << d->set->prevSelection();
         }
         if (!d->setListLater_set) {
             d->setListLater_set = true;
             d->changeSetLaterTimer.setSingleShot(true);
             d->changeSetLaterTimer.start(10);
         }
         return;
     }
 #endif
 
     const bool setChanged = d->set != set;
     if (d->set) {
         acceptInput();
         //store prev. selection for this prop set
         QModelIndex index = currentIndex();
         if (index.isValid()) {
 //! @todo This crashes when changing the interpreter type in the script plugin
 #if 0
             KProperty *property = d->model->propertyForIndex(index);
             //if (property->isNull())
             //    kprDebug() << "WTF? a NULL property?";
             //else
                 //d->set->setPreviousSelection(property->name());
 #endif
         }
         else {
             d->set->setPreviousSelection(QByteArray());
         }
         if (setChanged) {
             d->set->disconnect(this);
         }
     }
 
     QByteArray selectedPropertyName1 = propertyToSelect;
     QByteArray selectedPropertyName2 = propertyToSelect;
     if (options & SetOption::PreservePreviousSelection) {
         //try to find prev. selection:
         //1. in new list's prev. selection
         if (set)
             selectedPropertyName1 = set->previousSelection();
         //2. in prev. list's current selection
         if (d->set)
             selectedPropertyName2 = d->set->previousSelection();
     }
 
     if (setChanged) {
         d->set = set;
     }
     if (d->set && setChanged) {
         //receive property changes
         connect(d->set, SIGNAL(propertyChangedInternal(KPropertySet&,KProperty&)),
                 this, SLOT(slotPropertyChanged(KPropertySet&,KProperty&)));
         connect(d->set, SIGNAL(propertyReset(KPropertySet&,KProperty&)),
                 this, SLOT(slotPropertyReset(KPropertySet&,KProperty&)));
         connect(d->set, SIGNAL(aboutToBeCleared()), this, SLOT(slotSetWillBeCleared()));
         connect(d->set, SIGNAL(aboutToBeDeleted()), this, SLOT(slotSetWillBeDeleted()));
         connect(d->set, &KPropertySet::readOnlyFlagChanged,
                 this, &KPropertyEditorView::slotReadOnlyFlagChanged);
     }
 
     KPropertyEditorDataModel *oldModel = d->model;
     const KPropertySetIterator::Order setOrder
         = (options & SetOption::AlphabeticalOrder)
             ? KPropertySetIterator::Order::Alphabetical
             : KPropertySetIterator::Order::Insertion;
     d->model = d->set ? new KPropertyEditorDataModel(this, setOrder) : nullptr;
     setModel( d->model );
     delete oldModel;
 
     if (d->model && d->set && !d->set->isEmpty()) {
         d->expandIfNeeded();
     }
 
     emit propertySetChanged(d->set);
 
     if (d->set) {
         //select prev. selected item
         QModelIndex index;
         if (!selectedPropertyName2.isEmpty()) //try other one for old prop set
             index = d->model->indexForPropertyName( selectedPropertyName2 );
         if (!index.isValid() && !selectedPropertyName1.isEmpty()) //try old one for current prop set
             index = d->model->indexForPropertyName( selectedPropertyName1 );
 
         if (index.isValid()) {
             setCurrentIndex(index);
             scrollTo(index);
         }
     }
 }
 
 void KPropertyEditorView::slotSetWillBeCleared()
 {
     changeSet(nullptr, QByteArray());
 }
 
 void KPropertyEditorView::slotSetWillBeDeleted()
 {
     changeSet(nullptr, QByteArray());
 }
 
 void KPropertyEditorView::slotReadOnlyFlagChanged()
 {
     const QModelIndex index = currentIndex();
     setCurrentIndex(QModelIndex());
     if (index.isValid()) {
         selectionModel()->select(index, QItemSelectionModel::Select);
         setCurrentIndex(index);
     }
 }
 
 void KPropertyEditorView::setValueSyncEnabled(bool set)
 {
     d->valueSync = set;
 }
 
 bool KPropertyEditorView::isValueSyncEnabled() const
 {
     return d->valueSync;
 }
 
 void KPropertyEditorView::setChildPropertyItemsExpanded(bool set)
 {
     d->childPropertyItemsExpanded = set;
 }
 
 bool KPropertyEditorView::childPropertyItemsExpanded() const
 {
     return d->childPropertyItemsExpanded;
 }
 
 void KPropertyEditorView::setGroupItemsExpanded(bool set)
 {
     d->groupItemsExpanded = set;
 }
 
 bool KPropertyEditorView::groupItemsExpanded() const
 {
     return d->groupItemsExpanded;
 }
 
 bool KPropertyEditorView::groupsVisible() const
 {
     return d->groupsVisible;
 }
 
 void KPropertyEditorView::setGroupsVisible(bool set)
 {
     if (d->groupsVisible == set) {
         return;
     }
     if (d->model) {
         d->model->updateGroupsVisibility();
         d->expandIfNeeded();
     }
     viewport()->update();
 }
 
 void KPropertyEditorView::currentChanged( const QModelIndex & current, const QModelIndex & previous )
 {
     QTreeView::currentChanged( current, previous );
 }
 
 bool KPropertyEditorView::edit( const QModelIndex & index, EditTrigger trigger, QEvent * event )
 {
     bool result;
     if (!d->set || d->set->isReadOnly()) {
         result = false;
     } else {
         result = QTreeView::edit(index, trigger, event);
     }
     if (result) {
       QLineEdit *lineEditEditor = qobject_cast<QLineEdit*>(d->itemDelegate->m_currentEditor.data());
       if (lineEditEditor) {
         lineEditEditor->deselect();
         lineEditEditor->end(false);
       }
     }
     return result;
 }
 
 void KPropertyEditorView::drawBranches( QPainter * painter, const QRect & rect, const QModelIndex & index ) const
 {
     QTreeView::drawBranches( painter, rect, index );
 }
 
 void KPropertyEditorView::drawRow(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     if (!d->model) {
         return;
     }
     const KPropertyUtilsPrivate::PainterSaver saver(painter);
     const bool isGroupHeader(d->model->data(index, KPropertyEditorDataModel::PropertyGroupRole).toBool());
     QStyleOptionViewItem alteredOption(option);
     QTreeView::drawRow(painter, alteredOption, index);
     if (isGroupHeader) {
         // Special case: group header should be displayed over both columns. There's an issue with
         // alternate background which is painted over text in the 2nd column, so draw the text here
         // by hand.
         QFont font(alteredOption.font);
         font.setBold(true);
         alteredOption.font = font;
         painter->setFont(font);
         painter->drawText(
             alteredOption.rect.adjusted(style()->pixelMetric(QStyle::PM_TreeViewIndentation), 0, 0, 0),
             index.data(Qt::DisplayRole).toString(), Qt::AlignLeft | Qt::AlignVCenter);
     }
 }
 
 QRect KPropertyEditorView::revertButtonArea( const QModelIndex& index ) const
 {
     if (index.column() != 0 || !d->model)
         return QRect();
     QVariant modifiedVariant( d->model->data(index, KPropertyEditorDataModel::PropertyModifiedRole) );
     if (!modifiedVariant.isValid() || !modifiedVariant.toBool())
         return QRect();
     const int iconSize = getIconSize( fontInfo().pixelSize() );
     int x2 = columnWidth(0);
     int x1 = x2 - iconSize - 2;
     QRect r(visualRect(index));
     r.setLeft(x1);
     r.setRight(x2);
     return r;
 }
 
 bool KPropertyEditorView::withinRevertButtonArea( int x, const QModelIndex& index ) const
 {
     QRect r(revertButtonArea( index ));
     if (!r.isValid())
         return false;
     return r.left() < x && x < r.right();
 }
 
 void KPropertyEditorView::mousePressEvent ( QMouseEvent * event )
 {
     QTreeView::mousePressEvent( event );
     QModelIndex index = indexAt( event->pos() );
     setCurrentIndex(index);
     if (withinRevertButtonArea( event->x(), index )) {
         undo();
     }
 }
 
 void KPropertyEditorView::undo()
 {
     if (!d->set || d->set->isReadOnly() || !d->model)
         return;
 
     KProperty *property = d->model->propertyForIndex(currentIndex());
     if (effectiveValueSyncPolicy(property, d->valueSync)) {
         property->resetValue();
     }
 }
 
 void KPropertyEditorView::acceptInput()
 {
 //! @todo
 }
 
 void KPropertyEditorView::commitData( QWidget * editor )
 {
     QAbstractItemView::commitData( editor );
 }
 
 bool KPropertyEditorView::viewportEvent( QEvent * event )
 {
     if (event->type() == QEvent::ToolTip) {
         QHelpEvent *hevent = static_cast<QHelpEvent*>(event);
         const QModelIndex index = indexAt(hevent->pos());
         if (index.column() == 0 && withinRevertButtonArea( hevent->x(), index )) {
             QRect r(revertButtonArea( index ));
             QToolTip::showText(hevent->globalPos(), tr("Undo changes"), this, r);
         }
         else {
             QToolTip::hideText();
         }
     }
     return QTreeView::viewportEvent(event);
 }
 
 QSize KPropertyEditorView::sizeHint() const
 {
     return viewportSizeHint();
 }
 
 KPropertySet* KPropertyEditorView::propertySet() const
 {
     return d->set;
 }
 
 QColor KPropertyEditorView::gridLineColor() const
 {
     return d->gridLineColor;
 }
 
 void KPropertyEditorView::setGridLineColor(const QColor& color)
 {
     d->gridLineColor = color;
     viewport()->update();
 }
 
 static QModelIndex findChildItem(const KProperty& property, const QModelIndex &parent)
 {
     if (parent.model() && KPropertyUtils::propertyForIndex(parent) == &property) {
         return parent;
     }
     int row = 0;
     while (true) {
         QModelIndex childItem = parent.child(row, 0);
         if (childItem.isValid()) {
             QModelIndex subchild = findChildItem(property, childItem);
             if (subchild.isValid()) {
                 return subchild;
             }
         }
         else {
             return QModelIndex();
         }
         row++;
     }
 }
 
 void KPropertyEditorView::slotPropertyChanged(KPropertySet& set, KProperty& property)
 {
     Q_UNUSED(set);
     if (!d->slotPropertyChangedEnabled || !d->model)
         return;
     d->slotPropertyChangedEnabled = false;
     KProperty *realProperty = &property;
     while (realProperty->parent()) { // find top-level property
         realProperty = realProperty->parent();
     }
     const QModelIndex parentIndex( d->model->indexForPropertyName(realProperty->name()) );
     if (parentIndex.isValid()) {
         QModelIndex index = findChildItem(property, parentIndex);
         updateSubtree(index);
     }
     d->slotPropertyChangedEnabled = true;
 }
 
 void KPropertyEditorView::updateSubtree(const QModelIndex &index)
 {
     if (!index.isValid() || !d->model) {
         return;
     }
     update(index);
     update(index.parent());
     update(d->model->indexForColumn(index, 1));
     update(d->model->indexForColumn(index.parent(), 1));
 
     KProperty *property = static_cast<KProperty*>(index.internalPointer());
     if (property->children()) {
         int row = 0;
         foreach (KProperty* p, *property->children()) {
             updateSubtree(d->model->createIndex(row, 0, p));
             ++row;
         }
     }
 }
 
 void KPropertyEditorView::slotPropertyReset(KPropertySet& set, KProperty& property)
 {
 //! @todo OK?
     slotPropertyChanged(set, property);
 }
 
 
 bool KPropertyEditorView::toolTipsVisible() const
 {
     return d->toolTipsVisible;
 }
 
 void KPropertyEditorView::setToolTipsVisible(bool set)
 {
     d->toolTipsVisible = set;
 }