File indexing completed on 2024-05-12 04:35:09

 /****************************************************************************
 **
 ** 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"