--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/shared/qtpropertybrowser/qtbuttonpropertybrowser.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,627 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qtbuttonpropertybrowser.h"
+#include <QtCore/QSet>
+#include <QtGui/QGridLayout>
+#include <QtGui/QLabel>
+#include <QtCore/QTimer>
+#include <QtCore/QMap>
+#include <QtGui/QToolButton>
+#include <QtGui/QStyle>
+
+QT_BEGIN_NAMESPACE
+
+class QtButtonPropertyBrowserPrivate
+{
+ QtButtonPropertyBrowser *q_ptr;
+ Q_DECLARE_PUBLIC(QtButtonPropertyBrowser)
+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();
+ void slotToggled(bool checked);
+
+ struct WidgetItem
+ {
+ WidgetItem() : widget(0), label(0), widgetLabel(0),
+ button(0), container(0), layout(0), /*line(0), */parent(0), expanded(false) { }
+ QWidget *widget; // can be null
+ QLabel *label; // main label with property name
+ QLabel *widgetLabel; // label substitute showing the current value if there is no widget
+ QToolButton *button; // expandable button for items with children
+ QWidget *container; // container which is expanded when the button is clicked
+ QGridLayout *layout; // layout in container
+ WidgetItem *parent;
+ QList<WidgetItem *> children;
+ bool expanded;
+ };
+private:
+ void updateLater();
+ void updateItem(WidgetItem *item);
+ void insertRow(QGridLayout *layout, int row) const;
+ void removeRow(QGridLayout *layout, int row) const;
+ int gridRow(WidgetItem *item) const;
+ int gridSpan(WidgetItem *item) const;
+ void setExpanded(WidgetItem *item, bool expanded);
+ QToolButton *createButton(QWidget *panret = 0) const;
+
+ QMap<QtBrowserItem *, WidgetItem *> m_indexToItem;
+ QMap<WidgetItem *, QtBrowserItem *> m_itemToIndex;
+ QMap<QWidget *, WidgetItem *> m_widgetToItem;
+ QMap<QObject *, WidgetItem *> m_buttonToItem;
+ QGridLayout *m_mainLayout;
+ QList<WidgetItem *> m_children;
+ QList<WidgetItem *> m_recreateQueue;
+};
+
+QToolButton *QtButtonPropertyBrowserPrivate::createButton(QWidget *parent) const
+{
+ QToolButton *button = new QToolButton(parent);
+ button->setCheckable(true);
+ button->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));
+ button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
+ button->setArrowType(Qt::DownArrow);
+ button->setIconSize(QSize(3, 16));
+ /*
+ QIcon icon;
+ icon.addPixmap(q_ptr->style()->standardPixmap(QStyle::SP_ArrowDown), QIcon::Normal, QIcon::Off);
+ icon.addPixmap(q_ptr->style()->standardPixmap(QStyle::SP_ArrowUp), QIcon::Normal, QIcon::On);
+ button->setIcon(icon);
+ */
+ return button;
+}
+
+int QtButtonPropertyBrowserPrivate::gridRow(WidgetItem *item) const
+{
+ QList<WidgetItem *> siblings;
+ if (item->parent)
+ siblings = item->parent->children;
+ else
+ siblings = m_children;
+
+ int row = 0;
+ QListIterator<WidgetItem *> it(siblings);
+ while (it.hasNext()) {
+ WidgetItem *sibling = it.next();
+ if (sibling == item)
+ return row;
+ row += gridSpan(sibling);
+ }
+ return -1;
+}
+
+int QtButtonPropertyBrowserPrivate::gridSpan(WidgetItem *item) const
+{
+ if (item->container && item->expanded)
+ return 2;
+ return 1;
+}
+
+void QtButtonPropertyBrowserPrivate::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 QtButtonPropertyBrowserPrivate::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 QtButtonPropertyBrowserPrivate::slotUpdate()
+{
+ QListIterator<WidgetItem *> itItem(m_recreateQueue);
+ while (itItem.hasNext()) {
+ WidgetItem *item = itItem.next();
+
+ WidgetItem *parent = item->parent;
+ QWidget *w = 0;
+ QGridLayout *l = 0;
+ const int oldRow = gridRow(item);
+ if (parent) {
+ w = parent->container;
+ l = parent->layout;
+ } else {
+ w = q_ptr;
+ l = m_mainLayout;
+ }
+
+ int span = 1;
+ if (!item->widget && !item->widgetLabel)
+ 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 QtButtonPropertyBrowserPrivate::setExpanded(WidgetItem *item, bool expanded)
+{
+ if (item->expanded == expanded)
+ return;
+
+ if (!item->container)
+ return;
+
+ item->expanded = expanded;
+ const int row = gridRow(item);
+ WidgetItem *parent = item->parent;
+ QGridLayout *l = 0;
+ if (parent)
+ l = parent->layout;
+ else
+ l = m_mainLayout;
+
+ if (expanded) {
+ insertRow(l, row + 1);
+ l->addWidget(item->container, row + 1, 0, 1, 2);
+ item->container->show();
+ } else {
+ l->removeWidget(item->container);
+ item->container->hide();
+ removeRow(l, row + 1);
+ }
+
+ item->button->setChecked(expanded);
+ item->button->setArrowType(expanded ? Qt::UpArrow : Qt::DownArrow);
+}
+
+void QtButtonPropertyBrowserPrivate::slotToggled(bool checked)
+{
+ WidgetItem *item = m_buttonToItem.value(q_ptr->sender());
+ if (!item)
+ return;
+
+ setExpanded(item, checked);
+
+ if (checked)
+ emit q_ptr->expanded(m_itemToIndex.value(item));
+ else
+ emit q_ptr->collapsed(m_itemToIndex.value(item));
+}
+
+void QtButtonPropertyBrowserPrivate::updateLater()
+{
+ QTimer::singleShot(0, q_ptr, SLOT(slotUpdate()));
+}
+
+void QtButtonPropertyBrowserPrivate::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 {
+ row = gridRow(afterItem) + gridSpan(afterItem);
+ if (parentItem)
+ parentItem->children.insert(parentItem->children.indexOf(afterItem) + 1, newItem);
+ else
+ m_children.insert(m_children.indexOf(afterItem) + 1, newItem);
+ }
+
+ if (!parentItem) {
+ layout = m_mainLayout;
+ parentWidget = q_ptr;
+ } else {
+ if (!parentItem->container) {
+ m_recreateQueue.removeAll(parentItem);
+ WidgetItem *grandParent = parentItem->parent;
+ QWidget *w = 0;
+ QGridLayout *l = 0;
+ const int oldRow = gridRow(parentItem);
+ if (grandParent) {
+ w = grandParent->container;
+ l = grandParent->layout;
+ } else {
+ w = q_ptr;
+ l = m_mainLayout;
+ }
+ QFrame *container = new QFrame();
+ container->setFrameShape(QFrame::Panel);
+ container->setFrameShadow(QFrame::Raised);
+ parentItem->container = container;
+ parentItem->button = createButton();
+ m_buttonToItem[parentItem->button] = parentItem;
+ q_ptr->connect(parentItem->button, SIGNAL(toggled(bool)), q_ptr, SLOT(slotToggled(bool)));
+ parentItem->layout = new QGridLayout();
+ container->setLayout(parentItem->layout);
+ if (parentItem->label) {
+ l->removeWidget(parentItem->label);
+ delete parentItem->label;
+ parentItem->label = 0;
+ }
+ int span = 1;
+ if (!parentItem->widget && !parentItem->widgetLabel)
+ span = 2;
+ l->addWidget(parentItem->button, oldRow, 0, 1, span);
+ updateItem(parentItem);
+ }
+ layout = parentItem->layout;
+ parentWidget = parentItem->container;
+ }
+
+ newItem->label = new QLabel(parentWidget);
+ newItem->label->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
+ newItem->widget = createEditor(index->property(), parentWidget);
+ if (newItem->widget) {
+ QObject::connect(newItem->widget, SIGNAL(destroyed()), q_ptr, SLOT(slotEditorDestroyed()));
+ m_widgetToItem[newItem->widget] = newItem;
+ } else if (index->property()->hasValue()) {
+ newItem->widgetLabel = new QLabel(parentWidget);
+ newItem->widgetLabel->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed));
+ }
+
+ 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, span, 1);
+
+ m_itemToIndex[newItem] = index;
+ m_indexToItem[index] = newItem;
+
+ updateItem(newItem);
+}
+
+void QtButtonPropertyBrowserPrivate::propertyRemoved(QtBrowserItem *index)
+{
+ WidgetItem *item = m_indexToItem.value(index);
+
+ m_indexToItem.remove(index);
+ m_itemToIndex.remove(item);
+
+ WidgetItem *parentItem = item->parent;
+
+ const int row = gridRow(item);
+
+ if (parentItem)
+ parentItem->children.removeAt(parentItem->children.indexOf(item));
+ else
+ m_children.removeAt(m_children.indexOf(item));
+
+ const int colSpan = gridSpan(item);
+
+ m_buttonToItem.remove(item->button);
+
+ if (item->widget)
+ delete item->widget;
+ if (item->label)
+ delete item->label;
+ if (item->widgetLabel)
+ delete item->widgetLabel;
+ if (item->button)
+ delete item->button;
+ if (item->container)
+ delete item->container;
+
+ if (!parentItem) {
+ removeRow(m_mainLayout, row);
+ if (colSpan > 1)
+ removeRow(m_mainLayout, row);
+ } else if (parentItem->children.count() != 0) {
+ removeRow(parentItem->layout, row);
+ if (colSpan > 1)
+ removeRow(parentItem->layout, row);
+ } else {
+ const WidgetItem *grandParent = parentItem->parent;
+ QGridLayout *l = 0;
+ if (grandParent) {
+ l = grandParent->layout;
+ } else {
+ l = m_mainLayout;
+ }
+
+ const int parentRow = gridRow(parentItem);
+ const int parentSpan = gridSpan(parentItem);
+
+ l->removeWidget(parentItem->button);
+ l->removeWidget(parentItem->container);
+ delete parentItem->button;
+ delete parentItem->container;
+ parentItem->button = 0;
+ parentItem->container = 0;
+ parentItem->layout = 0;
+ if (!m_recreateQueue.contains(parentItem))
+ m_recreateQueue.append(parentItem);
+ if (parentSpan > 1)
+ removeRow(l, parentRow + 1);
+
+ updateLater();
+ }
+ m_recreateQueue.removeAll(item);
+
+ delete item;
+}
+
+void QtButtonPropertyBrowserPrivate::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 QtButtonPropertyBrowserPrivate::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());
+ }
+}
+
+void QtButtonPropertyBrowserPrivate::propertyChanged(QtBrowserItem *index)
+{
+ WidgetItem *item = m_indexToItem.value(index);
+
+ updateItem(item);
+}
+
+void QtButtonPropertyBrowserPrivate::updateItem(WidgetItem *item)
+{
+ QtProperty *property = m_itemToIndex[item]->property();
+ if (item->button) {
+ QFont font = item->button->font();
+ font.setUnderline(property->isModified());
+ item->button->setFont(font);
+ item->button->setText(property->propertyName());
+ item->button->setToolTip(property->toolTip());
+ item->button->setStatusTip(property->statusTip());
+ item->button->setWhatsThis(property->whatsThis());
+ item->button->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->toolTip());
+ 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->setToolTip(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());
+ item->widget->setToolTip(property->valueText());
+ }
+}
+
+
+
+/*!
+ \class QtButtonPropertyBrowser
+ \internal
+ \inmodule QtDesigner
+ \since 4.4
+
+ \brief The QtButtonPropertyBrowser class provides a drop down QToolButton
+ 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.
+
+ QtButtonPropertyBrowser provides drop down button for all nested
+ properties, i.e. subproperties are enclosed by a container associated with
+ the drop down button. The parent property's name is displayed as button text. For example:
+
+ \image qtbuttonpropertybrowser.png
+
+ Use the QtAbstractPropertyBrowser API to add, insert and remove
+ properties from an instance of the QtButtonPropertyBrowser
+ class. The properties themselves are created and managed by
+ implementations of the QtAbstractPropertyManager class.
+
+ \sa QtTreePropertyBrowser, QtAbstractPropertyBrowser
+*/
+
+/*!
+ \fn void QtButtonPropertyBrowser::collapsed(QtBrowserItem *item)
+
+ This signal is emitted when the \a item is collapsed.
+
+ \sa expanded(), setExpanded()
+*/
+
+/*!
+ \fn void QtButtonPropertyBrowser::expanded(QtBrowserItem *item)
+
+ This signal is emitted when the \a item is expanded.
+
+ \sa collapsed(), setExpanded()
+*/
+
+/*!
+ Creates a property browser with the given \a parent.
+*/
+QtButtonPropertyBrowser::QtButtonPropertyBrowser(QWidget *parent)
+ : QtAbstractPropertyBrowser(parent), d_ptr(new QtButtonPropertyBrowserPrivate)
+{
+ 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
+*/
+QtButtonPropertyBrowser::~QtButtonPropertyBrowser()
+{
+ const QMap<QtButtonPropertyBrowserPrivate::WidgetItem *, QtBrowserItem *>::ConstIterator icend = d_ptr->m_itemToIndex.constEnd();
+ for (QMap<QtButtonPropertyBrowserPrivate::WidgetItem *, QtBrowserItem *>::ConstIterator it = d_ptr->m_itemToIndex.constBegin(); it != icend; ++it)
+ delete it.key();
+}
+
+/*!
+ \reimp
+*/
+void QtButtonPropertyBrowser::itemInserted(QtBrowserItem *item, QtBrowserItem *afterItem)
+{
+ d_ptr->propertyInserted(item, afterItem);
+}
+
+/*!
+ \reimp
+*/
+void QtButtonPropertyBrowser::itemRemoved(QtBrowserItem *item)
+{
+ d_ptr->propertyRemoved(item);
+}
+
+/*!
+ \reimp
+*/
+void QtButtonPropertyBrowser::itemChanged(QtBrowserItem *item)
+{
+ d_ptr->propertyChanged(item);
+}
+
+/*!
+ Sets the \a item to either collapse or expanded, depending on the value of \a expanded.
+
+ \sa isExpanded(), expanded(), collapsed()
+*/
+
+void QtButtonPropertyBrowser::setExpanded(QtBrowserItem *item, bool expanded)
+{
+ QtButtonPropertyBrowserPrivate::WidgetItem *itm = d_ptr->m_indexToItem.value(item);
+ if (itm)
+ d_ptr->setExpanded(itm, expanded);
+}
+
+/*!
+ Returns true if the \a item is expanded; otherwise returns false.
+
+ \sa setExpanded()
+*/
+
+bool QtButtonPropertyBrowser::isExpanded(QtBrowserItem *item) const
+{
+ QtButtonPropertyBrowserPrivate::WidgetItem *itm = d_ptr->m_indexToItem.value(item);
+ if (itm)
+ return itm->expanded;
+ return false;
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qtbuttonpropertybrowser.cpp"