| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the tools applications of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "qtgroupboxpropertybrowser.h" |
| #include <QtCore/QSet> |
| #include <QtWidgets/QGridLayout> |
| #include <QtWidgets/QLabel> |
| #include <QtWidgets/QGroupBox> |
| #include <QtCore/QTimer> |
| #include <QtCore/QMap> |
| |
| QT_BEGIN_NAMESPACE |
| |
| class QtGroupBoxPropertyBrowserPrivate |
| { |
| QtGroupBoxPropertyBrowser *q_ptr; |
| Q_DECLARE_PUBLIC(QtGroupBoxPropertyBrowser) |
| public: |
| |
| void init(QWidget *parent); |
| |
| void propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex); |
| void propertyRemoved(QtBrowserItem *index); |
| void propertyChanged(QtBrowserItem *index); |
| QWidget *createEditor(QtProperty *property, QWidget *parent) const |
| { return q_ptr->createEditor(property, parent); } |
| |
| void slotEditorDestroyed(); |
| void slotUpdate(); |
| |
| struct WidgetItem |
| { |
| QWidget *widget{nullptr}; // can be null |
| QLabel *label{nullptr}; |
| QLabel *widgetLabel{nullptr}; |
| QGroupBox *groupBox{nullptr}; |
| QGridLayout *layout{nullptr}; |
| QFrame *line{nullptr}; |
| WidgetItem *parent{nullptr}; |
| QList<WidgetItem *> children; |
| }; |
| private: |
| void updateLater(); |
| void updateItem(WidgetItem *item); |
| void insertRow(QGridLayout *layout, int row) const; |
| void removeRow(QGridLayout *layout, int row) const; |
| |
| bool hasHeader(WidgetItem *item) const; |
| |
| QMap<QtBrowserItem *, WidgetItem *> m_indexToItem; |
| QMap<WidgetItem *, QtBrowserItem *> m_itemToIndex; |
| QMap<QWidget *, WidgetItem *> m_widgetToItem; |
| QGridLayout *m_mainLayout; |
| QList<WidgetItem *> m_children; |
| QList<WidgetItem *> m_recreateQueue; |
| }; |
| |
| void QtGroupBoxPropertyBrowserPrivate::init(QWidget *parent) |
| { |
| m_mainLayout = new QGridLayout(); |
| parent->setLayout(m_mainLayout); |
| QLayoutItem *item = new QSpacerItem(0, 0, |
| QSizePolicy::Fixed, QSizePolicy::Expanding); |
| m_mainLayout->addItem(item, 0, 0); |
| } |
| |
| void QtGroupBoxPropertyBrowserPrivate::slotEditorDestroyed() |
| { |
| QWidget *editor = qobject_cast<QWidget *>(q_ptr->sender()); |
| if (!editor) |
| return; |
| if (!m_widgetToItem.contains(editor)) |
| return; |
| m_widgetToItem[editor]->widget = 0; |
| m_widgetToItem.remove(editor); |
| } |
| |
| void QtGroupBoxPropertyBrowserPrivate::slotUpdate() |
| { |
| for (WidgetItem *item : qAsConst(m_recreateQueue)) { |
| WidgetItem *par = item->parent; |
| QWidget *w = 0; |
| QGridLayout *l = 0; |
| int oldRow = -1; |
| if (!par) { |
| w = q_ptr; |
| l = m_mainLayout; |
| oldRow = m_children.indexOf(item); |
| } else { |
| w = par->groupBox; |
| l = par->layout; |
| oldRow = par->children.indexOf(item); |
| if (hasHeader(par)) |
| oldRow += 2; |
| } |
| |
| if (item->widget) { |
| item->widget->setParent(w); |
| } else if (item->widgetLabel) { |
| item->widgetLabel->setParent(w); |
| } else { |
| item->widgetLabel = new QLabel(w); |
| } |
| int span = 1; |
| if (item->widget) |
| l->addWidget(item->widget, oldRow, 1, 1, 1); |
| else if (item->widgetLabel) |
| l->addWidget(item->widgetLabel, oldRow, 1, 1, 1); |
| else |
| span = 2; |
| item->label = new QLabel(w); |
| item->label->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed)); |
| l->addWidget(item->label, oldRow, 0, 1, span); |
| |
| updateItem(item); |
| } |
| m_recreateQueue.clear(); |
| } |
| |
| void QtGroupBoxPropertyBrowserPrivate::updateLater() |
| { |
| QTimer::singleShot(0, q_ptr, SLOT(slotUpdate())); |
| } |
| |
| void QtGroupBoxPropertyBrowserPrivate::propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex) |
| { |
| WidgetItem *afterItem = m_indexToItem.value(afterIndex); |
| WidgetItem *parentItem = m_indexToItem.value(index->parent()); |
| |
| WidgetItem *newItem = new WidgetItem(); |
| newItem->parent = parentItem; |
| |
| QGridLayout *layout = 0; |
| QWidget *parentWidget = 0; |
| int row = -1; |
| if (!afterItem) { |
| row = 0; |
| if (parentItem) |
| parentItem->children.insert(0, newItem); |
| else |
| m_children.insert(0, newItem); |
| } else { |
| if (parentItem) { |
| row = parentItem->children.indexOf(afterItem) + 1; |
| parentItem->children.insert(row, newItem); |
| } else { |
| row = m_children.indexOf(afterItem) + 1; |
| m_children.insert(row, newItem); |
| } |
| } |
| if (parentItem && hasHeader(parentItem)) |
| row += 2; |
| |
| if (!parentItem) { |
| layout = m_mainLayout; |
| parentWidget = q_ptr;; |
| } else { |
| if (!parentItem->groupBox) { |
| m_recreateQueue.removeAll(parentItem); |
| WidgetItem *par = parentItem->parent; |
| QWidget *w = 0; |
| QGridLayout *l = 0; |
| int oldRow = -1; |
| if (!par) { |
| w = q_ptr; |
| l = m_mainLayout; |
| oldRow = m_children.indexOf(parentItem); |
| } else { |
| w = par->groupBox; |
| l = par->layout; |
| oldRow = par->children.indexOf(parentItem); |
| if (hasHeader(par)) |
| oldRow += 2; |
| } |
| parentItem->groupBox = new QGroupBox(w); |
| parentItem->layout = new QGridLayout(); |
| parentItem->groupBox->setLayout(parentItem->layout); |
| if (parentItem->label) { |
| l->removeWidget(parentItem->label); |
| delete parentItem->label; |
| parentItem->label = 0; |
| } |
| if (parentItem->widget) { |
| l->removeWidget(parentItem->widget); |
| parentItem->widget->setParent(parentItem->groupBox); |
| parentItem->layout->addWidget(parentItem->widget, 0, 0, 1, 2); |
| parentItem->line = new QFrame(parentItem->groupBox); |
| } else if (parentItem->widgetLabel) { |
| l->removeWidget(parentItem->widgetLabel); |
| delete parentItem->widgetLabel; |
| parentItem->widgetLabel = 0; |
| } |
| if (parentItem->line) { |
| parentItem->line->setFrameShape(QFrame::HLine); |
| parentItem->line->setFrameShadow(QFrame::Sunken); |
| parentItem->layout->addWidget(parentItem->line, 1, 0, 1, 2); |
| } |
| l->addWidget(parentItem->groupBox, oldRow, 0, 1, 2); |
| updateItem(parentItem); |
| } |
| layout = parentItem->layout; |
| parentWidget = parentItem->groupBox; |
| } |
| |
| newItem->label = new QLabel(parentWidget); |
| newItem->label->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed)); |
| newItem->widget = createEditor(index->property(), parentWidget); |
| if (!newItem->widget) { |
| newItem->widgetLabel = new QLabel(parentWidget); |
| } else { |
| QObject::connect(newItem->widget, SIGNAL(destroyed()), q_ptr, SLOT(slotEditorDestroyed())); |
| m_widgetToItem[newItem->widget] = newItem; |
| } |
| |
| insertRow(layout, row); |
| int span = 1; |
| if (newItem->widget) |
| layout->addWidget(newItem->widget, row, 1); |
| else if (newItem->widgetLabel) |
| layout->addWidget(newItem->widgetLabel, row, 1); |
| else |
| span = 2; |
| layout->addWidget(newItem->label, row, 0, 1, span); |
| |
| m_itemToIndex[newItem] = index; |
| m_indexToItem[index] = newItem; |
| |
| updateItem(newItem); |
| } |
| |
| void QtGroupBoxPropertyBrowserPrivate::propertyRemoved(QtBrowserItem *index) |
| { |
| WidgetItem *item = m_indexToItem.value(index); |
| |
| m_indexToItem.remove(index); |
| m_itemToIndex.remove(item); |
| |
| WidgetItem *parentItem = item->parent; |
| |
| int row = -1; |
| |
| if (parentItem) { |
| row = parentItem->children.indexOf(item); |
| parentItem->children.removeAt(row); |
| if (hasHeader(parentItem)) |
| row += 2; |
| } else { |
| row = m_children.indexOf(item); |
| m_children.removeAt(row); |
| } |
| |
| if (item->widget) |
| delete item->widget; |
| if (item->label) |
| delete item->label; |
| if (item->widgetLabel) |
| delete item->widgetLabel; |
| if (item->groupBox) |
| delete item->groupBox; |
| |
| if (!parentItem) { |
| removeRow(m_mainLayout, row); |
| } else if (parentItem->children.count() != 0) { |
| removeRow(parentItem->layout, row); |
| } else { |
| WidgetItem *par = parentItem->parent; |
| QGridLayout *l = 0; |
| int oldRow = -1; |
| if (!par) { |
| l = m_mainLayout; |
| oldRow = m_children.indexOf(parentItem); |
| } else { |
| l = par->layout; |
| oldRow = par->children.indexOf(parentItem); |
| if (hasHeader(par)) |
| oldRow += 2; |
| } |
| |
| if (parentItem->widget) { |
| parentItem->widget->hide(); |
| parentItem->widget->setParent(0); |
| } else if (parentItem->widgetLabel) { |
| parentItem->widgetLabel->hide(); |
| parentItem->widgetLabel->setParent(0); |
| } else { |
| //parentItem->widgetLabel = new QLabel(w); |
| } |
| l->removeWidget(parentItem->groupBox); |
| delete parentItem->groupBox; |
| parentItem->groupBox = 0; |
| parentItem->line = 0; |
| parentItem->layout = 0; |
| if (!m_recreateQueue.contains(parentItem)) |
| m_recreateQueue.append(parentItem); |
| updateLater(); |
| } |
| m_recreateQueue.removeAll(item); |
| |
| delete item; |
| } |
| |
| void QtGroupBoxPropertyBrowserPrivate::insertRow(QGridLayout *layout, int row) const |
| { |
| QMap<QLayoutItem *, QRect> itemToPos; |
| int idx = 0; |
| while (idx < layout->count()) { |
| int r, c, rs, cs; |
| layout->getItemPosition(idx, &r, &c, &rs, &cs); |
| if (r >= row) { |
| itemToPos[layout->takeAt(idx)] = QRect(r + 1, c, rs, cs); |
| } else { |
| idx++; |
| } |
| } |
| |
| const QMap<QLayoutItem *, QRect>::ConstIterator icend = itemToPos.constEnd(); |
| for (QMap<QLayoutItem *, QRect>::ConstIterator it = itemToPos.constBegin(); it != icend; ++it) { |
| const QRect r = it.value(); |
| layout->addItem(it.key(), r.x(), r.y(), r.width(), r.height()); |
| } |
| } |
| |
| void QtGroupBoxPropertyBrowserPrivate::removeRow(QGridLayout *layout, int row) const |
| { |
| QMap<QLayoutItem *, QRect> itemToPos; |
| int idx = 0; |
| while (idx < layout->count()) { |
| int r, c, rs, cs; |
| layout->getItemPosition(idx, &r, &c, &rs, &cs); |
| if (r > row) { |
| itemToPos[layout->takeAt(idx)] = QRect(r - 1, c, rs, cs); |
| } else { |
| idx++; |
| } |
| } |
| |
| const QMap<QLayoutItem *, QRect>::ConstIterator icend = itemToPos.constEnd(); |
| for (QMap<QLayoutItem *, QRect>::ConstIterator it = itemToPos.constBegin(); it != icend; ++it) { |
| const QRect r = it.value(); |
| layout->addItem(it.key(), r.x(), r.y(), r.width(), r.height()); |
| } |
| } |
| |
| bool QtGroupBoxPropertyBrowserPrivate::hasHeader(WidgetItem *item) const |
| { |
| if (item->widget) |
| return true; |
| return false; |
| } |
| |
| void QtGroupBoxPropertyBrowserPrivate::propertyChanged(QtBrowserItem *index) |
| { |
| WidgetItem *item = m_indexToItem.value(index); |
| |
| updateItem(item); |
| } |
| |
| void QtGroupBoxPropertyBrowserPrivate::updateItem(WidgetItem *item) |
| { |
| QtProperty *property = m_itemToIndex[item]->property(); |
| if (item->groupBox) { |
| QFont font = item->groupBox->font(); |
| font.setUnderline(property->isModified()); |
| item->groupBox->setFont(font); |
| item->groupBox->setTitle(property->propertyName()); |
| item->groupBox->setToolTip(property->descriptionToolTip()); |
| item->groupBox->setStatusTip(property->statusTip()); |
| item->groupBox->setWhatsThis(property->whatsThis()); |
| item->groupBox->setEnabled(property->isEnabled()); |
| } |
| if (item->label) { |
| QFont font = item->label->font(); |
| font.setUnderline(property->isModified()); |
| item->label->setFont(font); |
| item->label->setText(property->propertyName()); |
| item->label->setToolTip(property->descriptionToolTip()); |
| item->label->setStatusTip(property->statusTip()); |
| item->label->setWhatsThis(property->whatsThis()); |
| item->label->setEnabled(property->isEnabled()); |
| } |
| if (item->widgetLabel) { |
| QFont font = item->widgetLabel->font(); |
| font.setUnderline(false); |
| item->widgetLabel->setFont(font); |
| item->widgetLabel->setText(property->valueText()); |
| item->widgetLabel->setEnabled(property->isEnabled()); |
| } |
| if (item->widget) { |
| QFont font = item->widget->font(); |
| font.setUnderline(false); |
| item->widget->setFont(font); |
| item->widget->setEnabled(property->isEnabled()); |
| const QString valueToolTip = property->valueToolTip(); |
| item->widget->setToolTip(valueToolTip.isEmpty() ? property->valueText() : valueToolTip); |
| } |
| //item->setIcon(1, property->valueIcon()); |
| } |
| |
| |
| |
| /*! |
| \class QtGroupBoxPropertyBrowser |
| \internal |
| \inmodule QtDesigner |
| \since 4.4 |
| |
| \brief The QtGroupBoxPropertyBrowser class provides a QGroupBox |
| based property browser. |
| |
| A property browser is a widget that enables the user to edit a |
| given set of properties. Each property is represented by a label |
| specifying the property's name, and an editing widget (e.g. a line |
| edit or a combobox) holding its value. A property can have zero or |
| more subproperties. |
| |
| QtGroupBoxPropertyBrowser provides group boxes for all nested |
| properties, i.e. subproperties are enclosed by a group box with |
| the parent property's name as its title. For example: |
| |
| \image qtgroupboxpropertybrowser.png |
| |
| Use the QtAbstractPropertyBrowser API to add, insert and remove |
| properties from an instance of the QtGroupBoxPropertyBrowser |
| class. The properties themselves are created and managed by |
| implementations of the QtAbstractPropertyManager class. |
| |
| \sa QtTreePropertyBrowser, QtAbstractPropertyBrowser |
| */ |
| |
| /*! |
| Creates a property browser with the given \a parent. |
| */ |
| QtGroupBoxPropertyBrowser::QtGroupBoxPropertyBrowser(QWidget *parent) |
| : QtAbstractPropertyBrowser(parent), d_ptr(new QtGroupBoxPropertyBrowserPrivate) |
| { |
| d_ptr->q_ptr = this; |
| |
| d_ptr->init(this); |
| } |
| |
| /*! |
| Destroys this property browser. |
| |
| Note that the properties that were inserted into this browser are |
| \e not destroyed since they may still be used in other |
| browsers. The properties are owned by the manager that created |
| them. |
| |
| \sa QtProperty, QtAbstractPropertyManager |
| */ |
| QtGroupBoxPropertyBrowser::~QtGroupBoxPropertyBrowser() |
| { |
| const QMap<QtGroupBoxPropertyBrowserPrivate::WidgetItem *, QtBrowserItem *>::ConstIterator icend = d_ptr->m_itemToIndex.constEnd(); |
| for (QMap<QtGroupBoxPropertyBrowserPrivate::WidgetItem *, QtBrowserItem *>::ConstIterator it = d_ptr->m_itemToIndex.constBegin(); it != icend; ++it) |
| delete it.key(); |
| } |
| |
| /*! |
| \reimp |
| */ |
| void QtGroupBoxPropertyBrowser::itemInserted(QtBrowserItem *item, QtBrowserItem *afterItem) |
| { |
| d_ptr->propertyInserted(item, afterItem); |
| } |
| |
| /*! |
| \reimp |
| */ |
| void QtGroupBoxPropertyBrowser::itemRemoved(QtBrowserItem *item) |
| { |
| d_ptr->propertyRemoved(item); |
| } |
| |
| /*! |
| \reimp |
| */ |
| void QtGroupBoxPropertyBrowser::itemChanged(QtBrowserItem *item) |
| { |
| d_ptr->propertyChanged(item); |
| } |
| |
| QT_END_NAMESPACE |
| |
| #include "moc_qtgroupboxpropertybrowser.cpp" |
