tools/shared/qtpropertybrowser/qttreepropertybrowser.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the tools applications of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "qttreepropertybrowser.h"
  43 #include <QtCore/QSet>
  44 #include <QtGui/QIcon>
  45 #include <QtGui/QTreeWidget>
  46 #include <QtGui/QItemDelegate>
  47 #include <QtGui/QHBoxLayout>
  48 #include <QtGui/QHeaderView>
  49 #include <QtGui/QPainter>
  50 #include <QtGui/QApplication>
  51 #include <QtGui/QFocusEvent>
  52 #include <QtGui/QStyle>
  53 #include <QtGui/QPalette>
  54
  55 QT_BEGIN_NAMESPACE
  56
  57 class QtPropertyEditorView;
  58
  59 class QtTreePropertyBrowserPrivate
  60 {
  61     QtTreePropertyBrowser *q_ptr;
  62     Q_DECLARE_PUBLIC(QtTreePropertyBrowser)
  63
  64 public:
  65     QtTreePropertyBrowserPrivate();
  66     void init(QWidget *parent);
  67
  68     void propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex);
  69     void propertyRemoved(QtBrowserItem *index);
  70     void propertyChanged(QtBrowserItem *index);
  71     QWidget *createEditor(QtProperty *property, QWidget *parent) const
  72         { return q_ptr->createEditor(property, parent); }
  73     QtProperty *indexToProperty(const QModelIndex &index) const;
  74     QTreeWidgetItem *indexToItem(const QModelIndex &index) const;
  75     QtBrowserItem *indexToBrowserItem(const QModelIndex &index) const;
  76     bool lastColumn(int column) const;
  77     void disableItem(QTreeWidgetItem *item) const;
  78     void enableItem(QTreeWidgetItem *item) const;
  79     bool hasValue(QTreeWidgetItem *item) const;
  80
  81     void slotCollapsed(const QModelIndex &index);
  82     void slotExpanded(const QModelIndex &index);
  83
  84     QColor calculatedBackgroundColor(QtBrowserItem *item) const;
  85
  86     QtPropertyEditorView *treeWidget() const { return m_treeWidget; }
  87     bool markPropertiesWithoutValue() const { return m_markPropertiesWithoutValue; }
  88
  89     QtBrowserItem *currentItem() const;
  90     void setCurrentItem(QtBrowserItem *browserItem, bool block);
  91     void editItem(QtBrowserItem *browserItem);
  92
  93     void slotCurrentBrowserItemChanged(QtBrowserItem *item);
  94     void slotCurrentTreeItemChanged(QTreeWidgetItem *newItem, QTreeWidgetItem *);
  95
  96     QTreeWidgetItem *editedItem() const;
  97
  98 private:
  99     void updateItem(QTreeWidgetItem *item);
 100
 101     QMap<QtBrowserItem *, QTreeWidgetItem *> m_indexToItem;
 102     QMap<QTreeWidgetItem *, QtBrowserItem *> m_itemToIndex;
 103
 104     QMap<QtBrowserItem *, QColor> m_indexToBackgroundColor;
 105
 106     QtPropertyEditorView *m_treeWidget;
 107
 108     bool m_headerVisible;
 109     QtTreePropertyBrowser::ResizeMode m_resizeMode;
 110     class QtPropertyEditorDelegate *m_delegate;
 111     bool m_markPropertiesWithoutValue;
 112     bool m_browserChangedBlocked;
 113     QIcon m_expandIcon;
 114 };
 115
 116 // ------------ QtPropertyEditorView
 117 class QtPropertyEditorView : public QTreeWidget
 118 {
 119     Q_OBJECT
 120 public:
 121     QtPropertyEditorView(QWidget *parent = 0);
 122
 123     void setEditorPrivate(QtTreePropertyBrowserPrivate *editorPrivate)
 124         { m_editorPrivate = editorPrivate; }
 125
 126     QTreeWidgetItem *indexToItem(const QModelIndex &index) const
 127         { return itemFromIndex(index); }
 128
 129 protected:
 130     void keyPressEvent(QKeyEvent *event);
 131     void mousePressEvent(QMouseEvent *event);
 132     void drawRow(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const;
 133
 134 private:
 135     QtTreePropertyBrowserPrivate *m_editorPrivate;
 136 };
 137
 138 QtPropertyEditorView::QtPropertyEditorView(QWidget *parent) :
 139     QTreeWidget(parent),
 140     m_editorPrivate(0)
 141 {
 142     connect(header(), SIGNAL(sectionDoubleClicked(int)), this, SLOT(resizeColumnToContents(int)));
 143 }
 144
 145 void QtPropertyEditorView::drawRow(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
 146 {
 147     QStyleOptionViewItemV3 opt = option;
 148     bool hasValue = true;
 149     if (m_editorPrivate) {
 150         QtProperty *property = m_editorPrivate->indexToProperty(index);
 151         if (property)
 152             hasValue = property->hasValue();
 153     }
 154     if (!hasValue && m_editorPrivate->markPropertiesWithoutValue()) {
 155         const QColor c = option.palette.color(QPalette::Dark);
 156         painter->fillRect(option.rect, c);
 157         opt.palette.setColor(QPalette::AlternateBase, c);
 158     } else {
 159         const QColor c = m_editorPrivate->calculatedBackgroundColor(m_editorPrivate->indexToBrowserItem(index));
 160         if (c.isValid()) {
 161             painter->fillRect(option.rect, c);
 162             opt.palette.setColor(QPalette::AlternateBase, c.lighter(112));
 163         }
 164     }
 165     QTreeWidget::drawRow(painter, opt, index);
 166     QColor color = static_cast<QRgb>(QApplication::style()->styleHint(QStyle::SH_Table_GridLineColor, &opt));
 167     painter->save();
 168     painter->setPen(QPen(color));
 169     painter->drawLine(opt.rect.x(), opt.rect.bottom(), opt.rect.right(), opt.rect.bottom());
 170     painter->restore();
 171 }
 172
 173 void QtPropertyEditorView::keyPressEvent(QKeyEvent *event)
 174 {
 175     switch (event->key()) {
 176     case Qt::Key_Return:
 177     case Qt::Key_Enter:
 178     case Qt::Key_Space: // Trigger Edit
 179         if (!m_editorPrivate->editedItem())
 180             if (const QTreeWidgetItem *item = currentItem())
 181                 if (item->columnCount() >= 2 && ((item->flags() & (Qt::ItemIsEditable | Qt::ItemIsEnabled)) == (Qt::ItemIsEditable | Qt::ItemIsEnabled))) {
 182                     event->accept();
 183                     // If the current position is at column 0, move to 1.
 184                     QModelIndex index = currentIndex();
 185                     if (index.column() == 0) {
 186                         index = index.sibling(index.row(), 1);
 187                         setCurrentIndex(index);
 188                     }
 189                     edit(index);
 190                     return;
 191                 }
 192         break;
 193     default:
 194         break;
 195     }
 196     QTreeWidget::keyPressEvent(event);
 197 }
 198
 199 void QtPropertyEditorView::mousePressEvent(QMouseEvent *event)
 200 {
 201     QTreeWidget::mousePressEvent(event);
 202     QTreeWidgetItem *item = itemAt(event->pos());
 203
 204     if (item) {
 205         if ((item != m_editorPrivate->editedItem()) && (event->button() == Qt::LeftButton)
 206                 && (header()->logicalIndexAt(event->pos().x()) == 1)
 207                 && ((item->flags() & (Qt::ItemIsEditable | Qt::ItemIsEnabled)) == (Qt::ItemIsEditable | Qt::ItemIsEnabled))) {
 208             editItem(item, 1);
 209         } else if (!m_editorPrivate->hasValue(item) && m_editorPrivate->markPropertiesWithoutValue() && !rootIsDecorated()) {
 210             if (event->pos().x() + header()->offset() < 20)
 211                 item->setExpanded(!item->isExpanded());
 212         }
 213     }
 214 }
 215
 216 // ------------ QtPropertyEditorDelegate
 217 class QtPropertyEditorDelegate : public QItemDelegate
 218 {
 219     Q_OBJECT
 220 public:
 221     QtPropertyEditorDelegate(QObject *parent = 0)
 222         : QItemDelegate(parent), m_editorPrivate(0), m_editedItem(0), m_editedWidget(0)
 223         {}
 224
 225     void setEditorPrivate(QtTreePropertyBrowserPrivate *editorPrivate)
 226         { m_editorPrivate = editorPrivate; }
 227
 228     QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option,
 229             const QModelIndex &index) const;
 230
 231     void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option,
 232             const QModelIndex &index) const;
 233
 234     void paint(QPainter *painter, const QStyleOptionViewItem &option,
 235             const QModelIndex &index) const;
 236
 237     QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const;
 238
 239     void setModelData(QWidget *, QAbstractItemModel *,
 240             const QModelIndex &) const {}
 241
 242     void setEditorData(QWidget *, const QModelIndex &) const {}
 243
 244     bool eventFilter(QObject *object, QEvent *event);
 245     void closeEditor(QtProperty *property);
 246
 247     QTreeWidgetItem *editedItem() const { return m_editedItem; }
 248
 249 private slots:
 250     void slotEditorDestroyed(QObject *object);
 251
 252 private:
 253     int indentation(const QModelIndex &index) const;
 254
 255     typedef QMap<QWidget *, QtProperty *> EditorToPropertyMap;
 256     mutable EditorToPropertyMap m_editorToProperty;
 257
 258     typedef QMap<QtProperty *, QWidget *> PropertyToEditorMap;
 259     mutable PropertyToEditorMap m_propertyToEditor;
 260     QtTreePropertyBrowserPrivate *m_editorPrivate;
 261     mutable QTreeWidgetItem *m_editedItem;
 262     mutable QWidget *m_editedWidget;
 263 };
 264
 265 int QtPropertyEditorDelegate::indentation(const QModelIndex &index) const
 266 {
 267     if (!m_editorPrivate)
 268         return 0;
 269
 270     QTreeWidgetItem *item = m_editorPrivate->indexToItem(index);
 271     int indent = 0;
 272     while (item->parent()) {
 273         item = item->parent();
 274         ++indent;
 275     }
 276     if (m_editorPrivate->treeWidget()->rootIsDecorated())
 277         ++indent;
 278     return indent * m_editorPrivate->treeWidget()->indentation();
 279 }
 280
 281 void QtPropertyEditorDelegate::slotEditorDestroyed(QObject *object)
 282 {
 283     if (QWidget *w = qobject_cast<QWidget *>(object)) {
 284         const EditorToPropertyMap::iterator it = m_editorToProperty.find(w);
 285         if (it != m_editorToProperty.end()) {
 286             m_propertyToEditor.remove(it.value());
 287             m_editorToProperty.erase(it);
 288         }
 289         if (m_editedWidget == w) {
 290             m_editedWidget = 0;
 291             m_editedItem = 0;
 292         }
 293     }
 294 }
 295
 296 void QtPropertyEditorDelegate::closeEditor(QtProperty *property)
 297 {
 298     if (QWidget *w = m_propertyToEditor.value(property, 0))
 299         w->deleteLater();
 300 }
 301
 302 QWidget *QtPropertyEditorDelegate::createEditor(QWidget *parent,
 303         const QStyleOptionViewItem &, const QModelIndex &index) const
 304 {
 305     if (index.column() == 1 && m_editorPrivate) {
 306         QtProperty *property = m_editorPrivate->indexToProperty(index);
 307         QTreeWidgetItem *item = m_editorPrivate->indexToItem(index);
 308         if (property && item && (item->flags() & Qt::ItemIsEnabled)) {
 309             QWidget *editor = m_editorPrivate->createEditor(property, parent);
 310             if (editor) {
 311                 editor->setAutoFillBackground(true);
 312                 editor->installEventFilter(const_cast<QtPropertyEditorDelegate *>(this));
 313                 connect(editor, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)));
 314                 m_propertyToEditor[property] = editor;
 315                 m_editorToProperty[editor] = property;
 316                 m_editedItem = item;
 317                 m_editedWidget = editor;
 318             }
 319             return editor;
 320         }
 321     }
 322     return 0;
 323 }
 324
 325 void QtPropertyEditorDelegate::updateEditorGeometry(QWidget *editor,
 326         const QStyleOptionViewItem &option, const QModelIndex &index) const
 327 {
 328     Q_UNUSED(index)
 329     editor->setGeometry(option.rect.adjusted(0, 0, 0, -1));
 330 }
 331
 332 void QtPropertyEditorDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,
 333             const QModelIndex &index) const
 334 {
 335     bool hasValue = true;
 336     if (m_editorPrivate) {
 337         QtProperty *property = m_editorPrivate->indexToProperty(index);
 338         if (property)
 339             hasValue = property->hasValue();
 340     }
 341     QStyleOptionViewItemV3 opt = option;
 342     if ((m_editorPrivate && index.column() == 0) || !hasValue) {
 343         QtProperty *property = m_editorPrivate->indexToProperty(index);
 344         if (property && property->isModified()) {
 345             opt.font.setBold(true);
 346             opt.fontMetrics = QFontMetrics(opt.font);
 347         }
 348     }
 349     QColor c;
 350     if (!hasValue && m_editorPrivate->markPropertiesWithoutValue()) {
 351         c = opt.palette.color(QPalette::Dark);
 352         opt.palette.setColor(QPalette::Text, opt.palette.color(QPalette::BrightText));
 353     } else {
 354         c = m_editorPrivate->calculatedBackgroundColor(m_editorPrivate->indexToBrowserItem(index));
 355         if (c.isValid() && (opt.features & QStyleOptionViewItemV2::Alternate))
 356             c = c.lighter(112);
 357     }
 358     if (c.isValid())
 359         painter->fillRect(option.rect, c);
 360     opt.state &= ~QStyle::State_HasFocus;
 361     QItemDelegate::paint(painter, opt, index);
 362
 363     opt.palette.setCurrentColorGroup(QPalette::Active);
 364     QColor color = static_cast<QRgb>(QApplication::style()->styleHint(QStyle::SH_Table_GridLineColor, &opt));
 365     painter->save();
 366     painter->setPen(QPen(color));
 367     if (!m_editorPrivate || (!m_editorPrivate->lastColumn(index.column()) && hasValue)) {
 368         int right = (option.direction == Qt::LeftToRight) ? option.rect.right() : option.rect.left();
 369         painter->drawLine(right, option.rect.y(), right, option.rect.bottom());
 370     }
 371     painter->restore();
 372 }
 373
 374 QSize QtPropertyEditorDelegate::sizeHint(const QStyleOptionViewItem &option,
 375             const QModelIndex &index) const
 376 {
 377     return QItemDelegate::sizeHint(option, index) + QSize(3, 4);
 378 }
 379
 380 bool QtPropertyEditorDelegate::eventFilter(QObject *object, QEvent *event)
 381 {
 382     if (event->type() == QEvent::FocusOut) {
 383         QFocusEvent *fe = static_cast<QFocusEvent *>(event);
 384         if (fe->reason() == Qt::ActiveWindowFocusReason)
 385             return false;
 386     }
 387     return QItemDelegate::eventFilter(object, event);
 388 }
 389
 390 //  -------- QtTreePropertyBrowserPrivate implementation
 391 QtTreePropertyBrowserPrivate::QtTreePropertyBrowserPrivate() :
 392     m_treeWidget(0),
 393     m_headerVisible(true),
 394     m_resizeMode(QtTreePropertyBrowser::Stretch),
 395     m_delegate(0),
 396     m_markPropertiesWithoutValue(false),
 397     m_browserChangedBlocked(false)
 398 {
 399 }
 400
 401 // Draw an icon indicating opened/closing branches
 402 static QIcon drawIndicatorIcon(const QPalette &palette, QStyle *style)
 403 {
 404     QPixmap pix(14, 14);
 405     pix.fill(Qt::transparent);
 406     QStyleOption branchOption;
 407     QRect r(QPoint(0, 0), pix.size());
 408     branchOption.rect = QRect(2, 2, 9, 9); // ### hardcoded in qcommonstyle.cpp
 409     branchOption.palette = palette;
 410     branchOption.state = QStyle::State_Children;
 411
 412     QPainter p;
 413     // Draw closed state
 414     p.begin(&pix);
 415     style->drawPrimitive(QStyle::PE_IndicatorBranch, &branchOption, &p);
 416     p.end();
 417     QIcon rc = pix;
 418     rc.addPixmap(pix, QIcon::Selected, QIcon::Off);
 419     // Draw opened state
 420     branchOption.state |= QStyle::State_Open;
 421     pix.fill(Qt::transparent);
 422     p.begin(&pix);
 423     style->drawPrimitive(QStyle::PE_IndicatorBranch, &branchOption, &p);
 424     p.end();
 425
 426     rc.addPixmap(pix, QIcon::Normal, QIcon::On);
 427     rc.addPixmap(pix, QIcon::Selected, QIcon::On);
 428     return rc;
 429 }
 430
 431 void QtTreePropertyBrowserPrivate::init(QWidget *parent)
 432 {
 433     QHBoxLayout *layout = new QHBoxLayout(parent);
 434     layout->setMargin(0);
 435     m_treeWidget = new QtPropertyEditorView(parent);
 436     m_treeWidget->setEditorPrivate(this);
 437     m_treeWidget->setIconSize(QSize(18, 18));
 438     layout->addWidget(m_treeWidget);
 439
 440     m_treeWidget->setColumnCount(2);
 441     QStringList labels;
 442     labels.append(QApplication::translate("QtTreePropertyBrowser", "Property", 0, QApplication::UnicodeUTF8));
 443     labels.append(QApplication::translate("QtTreePropertyBrowser", "Value", 0, QApplication::UnicodeUTF8));
 444     m_treeWidget->setHeaderLabels(labels);
 445     m_treeWidget->setAlternatingRowColors(true);
 446     m_treeWidget->setEditTriggers(QAbstractItemView::EditKeyPressed);
 447     m_delegate = new QtPropertyEditorDelegate(parent);
 448     m_delegate->setEditorPrivate(this);
 449     m_treeWidget->setItemDelegate(m_delegate);
 450     m_treeWidget->header()->setMovable(false);
 451     m_treeWidget->header()->setResizeMode(QHeaderView::Stretch);
 452
 453     m_expandIcon = drawIndicatorIcon(q_ptr->palette(), q_ptr->style());
 454
 455     QObject::connect(m_treeWidget, SIGNAL(collapsed(QModelIndex)), q_ptr, SLOT(slotCollapsed(QModelIndex)));
 456     QObject::connect(m_treeWidget, SIGNAL(expanded(QModelIndex)), q_ptr, SLOT(slotExpanded(QModelIndex)));
 457     QObject::connect(m_treeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)), q_ptr, SLOT(slotCurrentTreeItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)));
 458 }
 459
 460 QtBrowserItem *QtTreePropertyBrowserPrivate::currentItem() const
 461 {
 462     if (QTreeWidgetItem *treeItem = m_treeWidget->currentItem())
 463         return m_itemToIndex.value(treeItem);
 464     return 0;
 465 }
 466
 467 void QtTreePropertyBrowserPrivate::setCurrentItem(QtBrowserItem *browserItem, bool block)
 468 {
 469     const bool blocked = block ? m_treeWidget->blockSignals(true) : false;
 470     if (browserItem == 0)
 471         m_treeWidget->setCurrentItem(0);
 472     else
 473         m_treeWidget->setCurrentItem(m_indexToItem.value(browserItem));
 474     if (block)
 475         m_treeWidget->blockSignals(blocked);
 476 }
 477
 478 QtProperty *QtTreePropertyBrowserPrivate::indexToProperty(const QModelIndex &index) const
 479 {
 480     QTreeWidgetItem *item = m_treeWidget->indexToItem(index);
 481     QtBrowserItem *idx = m_itemToIndex.value(item);
 482     if (idx)
 483         return idx->property();
 484     return 0;
 485 }
 486
 487 QtBrowserItem *QtTreePropertyBrowserPrivate::indexToBrowserItem(const QModelIndex &index) const
 488 {
 489     QTreeWidgetItem *item = m_treeWidget->indexToItem(index);
 490     return m_itemToIndex.value(item);
 491 }
 492
 493 QTreeWidgetItem *QtTreePropertyBrowserPrivate::indexToItem(const QModelIndex &index) const
 494 {
 495     return m_treeWidget->indexToItem(index);
 496 }
 497
 498 bool QtTreePropertyBrowserPrivate::lastColumn(int column) const
 499 {
 500     return m_treeWidget->header()->visualIndex(column) == m_treeWidget->columnCount() - 1;
 501 }
 502
 503 void QtTreePropertyBrowserPrivate::disableItem(QTreeWidgetItem *item) const
 504 {
 505     Qt::ItemFlags flags = item->flags();
 506     if (flags & Qt::ItemIsEnabled) {
 507         flags &= ~Qt::ItemIsEnabled;
 508         item->setFlags(flags);
 509         m_delegate->closeEditor(m_itemToIndex[item]->property());
 510         const int childCount = item->childCount();
 511         for (int i = 0; i < childCount; i++) {
 512             QTreeWidgetItem *child = item->child(i);
 513             disableItem(child);
 514         }
 515     }
 516 }
 517
 518 void QtTreePropertyBrowserPrivate::enableItem(QTreeWidgetItem *item) const
 519 {
 520     Qt::ItemFlags flags = item->flags();
 521     flags |= Qt::ItemIsEnabled;
 522     item->setFlags(flags);
 523     const int childCount = item->childCount();
 524     for (int i = 0; i < childCount; i++) {
 525         QTreeWidgetItem *child = item->child(i);
 526         QtProperty *property = m_itemToIndex[child]->property();
 527         if (property->isEnabled()) {
 528             enableItem(child);
 529         }
 530     }
 531 }
 532
 533 bool QtTreePropertyBrowserPrivate::hasValue(QTreeWidgetItem *item) const
 534 {
 535     QtBrowserItem *browserItem = m_itemToIndex.value(item);
 536     if (browserItem)
 537         return browserItem->property()->hasValue();
 538     return false;
 539 }
 540
 541 void QtTreePropertyBrowserPrivate::propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex)
 542 {
 543     QTreeWidgetItem *afterItem = m_indexToItem.value(afterIndex);
 544     QTreeWidgetItem *parentItem = m_indexToItem.value(index->parent());
 545
 546     QTreeWidgetItem *newItem = 0;
 547     if (parentItem) {
 548         newItem = new QTreeWidgetItem(parentItem, afterItem);
 549     } else {
 550         newItem = new QTreeWidgetItem(m_treeWidget, afterItem);
 551     }
 552     m_itemToIndex[newItem] = index;
 553     m_indexToItem[index] = newItem;
 554
 555     newItem->setFlags(newItem->flags() | Qt::ItemIsEditable);
 556     m_treeWidget->setItemExpanded(newItem, true);
 557
 558     updateItem(newItem);
 559 }
 560
 561 void QtTreePropertyBrowserPrivate::propertyRemoved(QtBrowserItem *index)
 562 {
 563     QTreeWidgetItem *item = m_indexToItem.value(index);
 564
 565     if (m_treeWidget->currentItem() == item) {
 566         m_treeWidget->setCurrentItem(0);
 567     }
 568
 569     delete item;
 570
 571     m_indexToItem.remove(index);
 572     m_itemToIndex.remove(item);
 573     m_indexToBackgroundColor.remove(index);
 574 }
 575
 576 void QtTreePropertyBrowserPrivate::propertyChanged(QtBrowserItem *index)
 577 {
 578     QTreeWidgetItem *item = m_indexToItem.value(index);
 579
 580     updateItem(item);
 581 }
 582
 583 void QtTreePropertyBrowserPrivate::updateItem(QTreeWidgetItem *item)
 584 {
 585     QtProperty *property = m_itemToIndex[item]->property();
 586     QIcon expandIcon;
 587     if (property->hasValue()) {
 588         QString toolTip = property->toolTip();
 589         if (toolTip.isEmpty())
 590             toolTip = property->valueText();
 591         item->setToolTip(1, toolTip);
 592         item->setIcon(1, property->valueIcon());
 593         item->setText(1, property->valueText());
 594     } else if (markPropertiesWithoutValue() && !m_treeWidget->rootIsDecorated()) {
 595         expandIcon = m_expandIcon;
 596     }
 597     item->setIcon(0, expandIcon);
 598     item->setFirstColumnSpanned(!property->hasValue());
 599     item->setToolTip(0, property->propertyName());
 600     item->setStatusTip(0, property->statusTip());
 601     item->setWhatsThis(0, property->whatsThis());
 602     item->setText(0, property->propertyName());
 603     bool wasEnabled = item->flags() & Qt::ItemIsEnabled;
 604     bool isEnabled = wasEnabled;
 605     if (property->isEnabled()) {
 606         QTreeWidgetItem *parent = item->parent();
 607         if (!parent || (parent->flags() & Qt::ItemIsEnabled))
 608             isEnabled = true;
 609         else
 610             isEnabled = false;
 611     } else {
 612         isEnabled = false;
 613     }
 614     if (wasEnabled != isEnabled) {
 615         if (isEnabled)
 616             enableItem(item);
 617         else
 618             disableItem(item);
 619     }
 620     m_treeWidget->viewport()->update();
 621 }
 622
 623 QColor QtTreePropertyBrowserPrivate::calculatedBackgroundColor(QtBrowserItem *item) const
 624 {
 625     QtBrowserItem *i = item;
 626     const QMap<QtBrowserItem *, QColor>::const_iterator itEnd = m_indexToBackgroundColor.constEnd();
 627     while (i) {
 628         QMap<QtBrowserItem *, QColor>::const_iterator it = m_indexToBackgroundColor.constFind(i);
 629         if (it != itEnd)
 630             return it.value();
 631         i = i->parent();
 632     }
 633     return QColor();
 634 }
 635
 636 void QtTreePropertyBrowserPrivate::slotCollapsed(const QModelIndex &index)
 637 {
 638     QTreeWidgetItem *item = indexToItem(index);
 639     QtBrowserItem *idx = m_itemToIndex.value(item);
 640     if (item)
 641         emit q_ptr->collapsed(idx);
 642 }
 643
 644 void QtTreePropertyBrowserPrivate::slotExpanded(const QModelIndex &index)
 645 {
 646     QTreeWidgetItem *item = indexToItem(index);
 647     QtBrowserItem *idx = m_itemToIndex.value(item);
 648     if (item)
 649         emit q_ptr->expanded(idx);
 650 }
 651
 652 void QtTreePropertyBrowserPrivate::slotCurrentBrowserItemChanged(QtBrowserItem *item)
 653 {
 654     if (!m_browserChangedBlocked && item != currentItem())
 655         setCurrentItem(item, true);
 656 }
 657
 658 void QtTreePropertyBrowserPrivate::slotCurrentTreeItemChanged(QTreeWidgetItem *newItem, QTreeWidgetItem *)
 659 {
 660     QtBrowserItem *browserItem = newItem ? m_itemToIndex.value(newItem) : 0;
 661     m_browserChangedBlocked = true;
 662     q_ptr->setCurrentItem(browserItem);
 663     m_browserChangedBlocked = false;
 664 }
 665
 666 QTreeWidgetItem *QtTreePropertyBrowserPrivate::editedItem() const
 667 {
 668     return m_delegate->editedItem();
 669 }
 670
 671 void QtTreePropertyBrowserPrivate::editItem(QtBrowserItem *browserItem)
 672 {
 673     if (QTreeWidgetItem *treeItem = m_indexToItem.value(browserItem, 0)) {
 674         m_treeWidget->setCurrentItem (treeItem, 1);
 675         m_treeWidget->editItem(treeItem, 1);
 676     }
 677 }
 678
 679 /*!
 680     \class QtTreePropertyBrowser
 681     \internal
 682     \inmodule QtDesigner
 683     \since 4.4
 684
 685     \brief The QtTreePropertyBrowser class provides QTreeWidget based
 686     property browser.
 687
 688     A property browser is a widget that enables the user to edit a
 689     given set of properties. Each property is represented by a label
 690     specifying the property's name, and an editing widget (e.g. a line
 691     edit or a combobox) holding its value. A property can have zero or
 692     more subproperties.
 693
 694     QtTreePropertyBrowser provides a tree based view for all nested
 695     properties, i.e. properties that have subproperties can be in an
 696     expanded (subproperties are visible) or collapsed (subproperties
 697     are hidden) state. For example:
 698
 699     \image qttreepropertybrowser.png
 700
 701     Use the QtAbstractPropertyBrowser API to add, insert and remove
 702     properties from an instance of the QtTreePropertyBrowser class.
 703     The properties themselves are created and managed by
 704     implementations of the QtAbstractPropertyManager class.
 705
 706     \sa QtGroupBoxPropertyBrowser, QtAbstractPropertyBrowser
 707 */
 708
 709 /*!
 710     \fn void QtTreePropertyBrowser::collapsed(QtBrowserItem *item)
 711
 712     This signal is emitted when the \a item is collapsed.
 713
 714     \sa expanded(), setExpanded()
 715 */
 716
 717 /*!
 718     \fn void QtTreePropertyBrowser::expanded(QtBrowserItem *item)
 719
 720     This signal is emitted when the \a item is expanded.
 721
 722     \sa collapsed(), setExpanded()
 723 */
 724
 725 /*!
 726     Creates a property browser with the given \a parent.
 727 */
 728 QtTreePropertyBrowser::QtTreePropertyBrowser(QWidget *parent)
 729     : QtAbstractPropertyBrowser(parent), d_ptr(new QtTreePropertyBrowserPrivate)
 730 {
 731     d_ptr->q_ptr = this;
 732
 733     d_ptr->init(this);
 734     connect(this, SIGNAL(currentItemChanged(QtBrowserItem*)), this, SLOT(slotCurrentBrowserItemChanged(QtBrowserItem*)));
 735 }
 736
 737 /*!
 738     Destroys this property browser.
 739
 740     Note that the properties that were inserted into this browser are
 741     \e not destroyed since they may still be used in other
 742     browsers. The properties are owned by the manager that created
 743     them.
 744
 745     \sa QtProperty, QtAbstractPropertyManager
 746 */
 747 QtTreePropertyBrowser::~QtTreePropertyBrowser()
 748 {
 749 }
 750
 751 /*!
 752     \property QtTreePropertyBrowser::indentation
 753     \brief indentation of the items in the tree view.
 754 */
 755 int QtTreePropertyBrowser::indentation() const
 756 {
 757     return d_ptr->m_treeWidget->indentation();
 758 }
 759
 760 void QtTreePropertyBrowser::setIndentation(int i)
 761 {
 762     d_ptr->m_treeWidget->setIndentation(i);
 763 }
 764
 765 /*!
 766   \property QtTreePropertyBrowser::rootIsDecorated
 767   \brief whether to show controls for expanding and collapsing root items.
 768 */
 769 bool QtTreePropertyBrowser::rootIsDecorated() const
 770 {
 771     return d_ptr->m_treeWidget->rootIsDecorated();
 772 }
 773
 774 void QtTreePropertyBrowser::setRootIsDecorated(bool show)
 775 {
 776     d_ptr->m_treeWidget->setRootIsDecorated(show);
 777     QMapIterator<QTreeWidgetItem *, QtBrowserItem *> it(d_ptr->m_itemToIndex);
 778     while (it.hasNext()) {
 779         QtProperty *property = it.next().value()->property();
 780         if (!property->hasValue())
 781             d_ptr->updateItem(it.key());
 782     }
 783 }
 784
 785 /*!
 786   \property QtTreePropertyBrowser::alternatingRowColors
 787   \brief whether to draw the background using alternating colors.
 788   By default this property is set to true.
 789 */
 790 bool QtTreePropertyBrowser::alternatingRowColors() const
 791 {
 792     return d_ptr->m_treeWidget->alternatingRowColors();
 793 }
 794
 795 void QtTreePropertyBrowser::setAlternatingRowColors(bool enable)
 796 {
 797     d_ptr->m_treeWidget->setAlternatingRowColors(enable);
 798     QMapIterator<QTreeWidgetItem *, QtBrowserItem *> it(d_ptr->m_itemToIndex);
 799 }
 800
 801 /*!
 802   \property QtTreePropertyBrowser::headerVisible
 803   \brief whether to show the header.
 804 */
 805 bool QtTreePropertyBrowser::isHeaderVisible() const
 806 {
 807     return d_ptr->m_headerVisible;
 808 }
 809
 810 void QtTreePropertyBrowser::setHeaderVisible(bool visible)
 811 {
 812     if (d_ptr->m_headerVisible == visible)
 813         return;
 814
 815     d_ptr->m_headerVisible = visible;
 816     d_ptr->m_treeWidget->header()->setVisible(visible);
 817 }
 818
 819 /*!
 820   \enum QtTreePropertyBrowser::ResizeMode
 821
 822   The resize mode specifies the behavior of the header sections.
 823
 824   \value Interactive The user can resize the sections.
 825   The sections can also be resized programmatically using setSplitterPosition().
 826
 827   \value Fixed The user cannot resize the section.
 828   The section can only be resized programmatically using setSplitterPosition().
 829
 830   \value Stretch QHeaderView will automatically resize the section to fill the available space.
 831   The size cannot be changed by the user or programmatically.
 832
 833   \value ResizeToContents QHeaderView will automatically resize the section to its optimal
 834   size based on the contents of the entire column.
 835   The size cannot be changed by the user or programmatically.
 836
 837   \sa setResizeMode()
 838 */
 839
 840 /*!
 841     \property QtTreePropertyBrowser::resizeMode
 842     \brief the resize mode of setions in the header.
 843 */
 844
 845 QtTreePropertyBrowser::ResizeMode QtTreePropertyBrowser::resizeMode() const
 846 {
 847     return d_ptr->m_resizeMode;
 848 }
 849
 850 void QtTreePropertyBrowser::setResizeMode(QtTreePropertyBrowser::ResizeMode mode)
 851 {
 852     if (d_ptr->m_resizeMode == mode)
 853         return;
 854
 855     d_ptr->m_resizeMode = mode;
 856     QHeaderView::ResizeMode m = QHeaderView::Stretch;
 857     switch (mode) {
 858         case QtTreePropertyBrowser::Interactive:      m = QHeaderView::Interactive;      break;
 859         case QtTreePropertyBrowser::Fixed:            m = QHeaderView::Fixed;            break;
 860         case QtTreePropertyBrowser::ResizeToContents: m = QHeaderView::ResizeToContents; break;
 861         case QtTreePropertyBrowser::Stretch:
 862         default:                                      m = QHeaderView::Stretch;          break;
 863     }
 864     d_ptr->m_treeWidget->header()->setResizeMode(m);
 865 }
 866
 867 /*!
 868     \property QtTreePropertyBrowser::splitterPosition
 869     \brief the position of the splitter between the colunms.
 870 */
 871
 872 int QtTreePropertyBrowser::splitterPosition() const
 873 {
 874     return d_ptr->m_treeWidget->header()->sectionSize(0);
 875 }
 876
 877 void QtTreePropertyBrowser::setSplitterPosition(int position)
 878 {
 879     d_ptr->m_treeWidget->header()->resizeSection(0, position);
 880 }
 881
 882 /*!
 883     Sets the \a item to either collapse or expanded, depending on the value of \a expanded.
 884
 885     \sa isExpanded(), expanded(), collapsed()
 886 */
 887
 888 void QtTreePropertyBrowser::setExpanded(QtBrowserItem *item, bool expanded)
 889 {
 890     QTreeWidgetItem *treeItem = d_ptr->m_indexToItem.value(item);
 891     if (treeItem)
 892         treeItem->setExpanded(expanded);
 893 }
 894
 895 /*!
 896     Returns true if the \a item is expanded; otherwise returns false.
 897
 898     \sa setExpanded()
 899 */
 900
 901 bool QtTreePropertyBrowser::isExpanded(QtBrowserItem *item) const
 902 {
 903     QTreeWidgetItem *treeItem = d_ptr->m_indexToItem.value(item);
 904     if (treeItem)
 905         return treeItem->isExpanded();
 906     return false;
 907 }
 908
 909 /*!
 910     Returns true if the \a item is visible; otherwise returns false.
 911
 912     \sa setItemVisible()
 913     \since 4.5
 914 */
 915
 916 bool QtTreePropertyBrowser::isItemVisible(QtBrowserItem *item) const
 917 {
 918     if (const QTreeWidgetItem *treeItem = d_ptr->m_indexToItem.value(item))
 919         return !treeItem->isHidden();
 920     return false;
 921 }
 922
 923 /*!
 924     Sets the \a item to be visible, depending on the value of \a visible.
 925
 926    \sa isItemVisible()
 927    \since 4.5
 928 */
 929
 930 void QtTreePropertyBrowser::setItemVisible(QtBrowserItem *item, bool visible)
 931 {
 932     if (QTreeWidgetItem *treeItem = d_ptr->m_indexToItem.value(item))
 933         treeItem->setHidden(!visible);
 934 }
 935
 936 /*!
 937     Sets the \a item's background color to \a color. Note that while item's background
 938     is rendered every second row is being drawn with alternate color (which is a bit lighter than items \a color)
 939
 940     \sa backgroundColor(), calculatedBackgroundColor()
 941 */
 942
 943 void QtTreePropertyBrowser::setBackgroundColor(QtBrowserItem *item, const QColor &color)
 944 {
 945     if (!d_ptr->m_indexToItem.contains(item))
 946         return;
 947     if (color.isValid())
 948         d_ptr->m_indexToBackgroundColor[item] = color;
 949     else
 950         d_ptr->m_indexToBackgroundColor.remove(item);
 951     d_ptr->m_treeWidget->viewport()->update();
 952 }
 953
 954 /*!
 955     Returns the \a item's color. If there is no color set for item it returns invalid color.
 956
 957     \sa calculatedBackgroundColor(), setBackgroundColor()
 958 */
 959
 960 QColor QtTreePropertyBrowser::backgroundColor(QtBrowserItem *item) const
 961 {
 962     return d_ptr->m_indexToBackgroundColor.value(item);
 963 }
 964
 965 /*!
 966     Returns the \a item's color. If there is no color set for item it returns parent \a item's
 967     color (if there is no color set for parent it returns grandparent's color and so on). In case
 968     the color is not set for \a item and it's top level item it returns invalid color.
 969
 970     \sa backgroundColor(), setBackgroundColor()
 971 */
 972
 973 QColor QtTreePropertyBrowser::calculatedBackgroundColor(QtBrowserItem *item) const
 974 {
 975     return d_ptr->calculatedBackgroundColor(item);
 976 }
 977
 978 /*!
 979     \property QtTreePropertyBrowser::propertiesWithoutValueMarked
 980     \brief whether to enable or disable marking properties without value.
 981
 982     When marking is enabled the item's background is rendered in dark color and item's
 983     foreground is rendered with light color.
 984
 985     \sa propertiesWithoutValueMarked()
 986 */
 987 void QtTreePropertyBrowser::setPropertiesWithoutValueMarked(bool mark)
 988 {
 989     if (d_ptr->m_markPropertiesWithoutValue == mark)
 990         return;
 991
 992     d_ptr->m_markPropertiesWithoutValue = mark;
 993     QMapIterator<QTreeWidgetItem *, QtBrowserItem *> it(d_ptr->m_itemToIndex);
 994     while (it.hasNext()) {
 995         QtProperty *property = it.next().value()->property();
 996         if (!property->hasValue())
 997             d_ptr->updateItem(it.key());
 998     }
 999     d_ptr->m_treeWidget->viewport()->update();
1000 }
1001
1002 bool QtTreePropertyBrowser::propertiesWithoutValueMarked() const
1003 {
1004     return d_ptr->m_markPropertiesWithoutValue;
1005 }
1006
1007 /*!
1008     \reimp
1009 */
1010 void QtTreePropertyBrowser::itemInserted(QtBrowserItem *item, QtBrowserItem *afterItem)
1011 {
1012     d_ptr->propertyInserted(item, afterItem);
1013 }
1014
1015 /*!
1016     \reimp
1017 */
1018 void QtTreePropertyBrowser::itemRemoved(QtBrowserItem *item)
1019 {
1020     d_ptr->propertyRemoved(item);
1021 }
1022
1023 /*!
1024     \reimp
1025 */
1026 void QtTreePropertyBrowser::itemChanged(QtBrowserItem *item)
1027 {
1028     d_ptr->propertyChanged(item);
1029 }
1030
1031 /*!
1032     Sets the current item to \a item and opens the relevant editor for it.
1033 */
1034 void QtTreePropertyBrowser::editItem(QtBrowserItem *item)
1035 {
1036     d_ptr->editItem(item);
1037 }
1038
1039 QT_END_NAMESPACE
1040
1041 #include "moc_qttreepropertybrowser.cpp"
1042 #include "qttreepropertybrowser.moc"