Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qtgroupboxpropertybrowser_p.h"
#include <QtWidgets/qgridlayout.h>
#include <QtWidgets/qgroupbox.h>
#include <QtWidgets/qlabel.h>
#include <QtCore/qhash.h>
QT_BEGIN_NAMESPACE
class QtGroupBoxPropertyBrowserPrivate
{
QtGroupBoxPropertyBrowser *q_ptr = nullptr;
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 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);
static void insertRow(QGridLayout *layout, int row);
static void removeRow(QGridLayout *layout, int row);
static bool hasHeader(const WidgetItem *item);
QHash<QtBrowserItem *, WidgetItem *> m_indexToItem;
QHash<WidgetItem *, QtBrowserItem *> m_itemToIndex;
QGridLayout *m_mainLayout;
QList<WidgetItem *> m_children;
QList<WidgetItem *> m_recreateQueue;
};
void QtGroupBoxPropertyBrowserPrivate::init(QWidget *parent)
{
m_mainLayout = new QGridLayout();
parent->setLayout(m_mainLayout);
auto *item = new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding);
m_mainLayout->addItem(item, 0, 0);
}
void QtGroupBoxPropertyBrowserPrivate::slotUpdate()
{
for (WidgetItem *item : std::as_const(m_recreateQueue)) {
WidgetItem *par = item->parent;
QWidget *w = nullptr;
QGridLayout *l = nullptr;
qsizetype 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()
{
QMetaObject::invokeMethod(q_ptr, [this] { slotUpdate(); }, Qt::QueuedConnection);
}
void QtGroupBoxPropertyBrowserPrivate::propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex)
{
WidgetItem *afterItem = m_indexToItem.value(afterIndex);
WidgetItem *parentItem = m_indexToItem.value(index->parent());
auto *newItem = new WidgetItem();
newItem->parent = parentItem;
QGridLayout *layout = nullptr;
QWidget *parentWidget = nullptr;
qsizetype 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 = nullptr;
QGridLayout *l = nullptr;
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 = nullptr;
}
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 = nullptr;
}
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);
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;
qsizetype 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);
}
delete item->widget;
delete item->label;
delete item->widgetLabel;
delete item->groupBox;
if (!parentItem) {
removeRow(m_mainLayout, row);
} else if (!parentItem->children.empty()) {
removeRow(parentItem->layout, row);
} else {
WidgetItem *par = parentItem->parent;
QGridLayout *l = (par ? par->layout : m_mainLayout);
if (parentItem->widget) {
parentItem->widget->hide();
parentItem->widget->setParent(nullptr);
} else if (parentItem->widgetLabel) {
parentItem->widgetLabel->hide();
parentItem->widgetLabel->setParent(nullptr);
} else {
//parentItem->widgetLabel = new QLabel(w);
}
l->removeWidget(parentItem->groupBox);
delete parentItem->groupBox;
parentItem->groupBox = nullptr;
parentItem->line = nullptr;
parentItem->layout = nullptr;
if (!m_recreateQueue.contains(parentItem))
m_recreateQueue.append(parentItem);
updateLater();
}
m_recreateQueue.removeAll(item);
delete item;
}
void QtGroupBoxPropertyBrowserPrivate::insertRow(QGridLayout *layout, int row)
{
QHash<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++;
}
}
for (auto it = itemToPos.cbegin(), icend = itemToPos.cend(); 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)
{
QHash<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++;
}
}
for (auto it = itemToPos.cbegin(), icend = itemToPos.cend(); it != icend; ++it) {
const QRect r = it.value();
layout->addItem(it.key(), r.x(), r.y(), r.width(), r.height());
}
}
bool QtGroupBoxPropertyBrowserPrivate::hasHeader(const WidgetItem *item)
{
return item->widget;
}
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()
{
for (auto it = d_ptr->m_itemToIndex.cbegin(), icend = d_ptr->m_itemToIndex.cend(); 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_p.cpp"