1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 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 "qtbuttonpropertybrowser.h"

    43 #include <QtCore/QSet>

    44 #include <QtGui/QGridLayout>

    45 #include <QtGui/QLabel>

    46 #include <QtCore/QTimer>

    47 #include <QtCore/QMap>

    48 #include <QtGui/QToolButton>

    49 #include <QtGui/QStyle>

    50 

    51 QT_BEGIN_NAMESPACE

    52 

    53 class QtButtonPropertyBrowserPrivate

    54 {

    55     QtButtonPropertyBrowser *q_ptr;

    56     Q_DECLARE_PUBLIC(QtButtonPropertyBrowser)

    57 public:

    58 

    59     void init(QWidget *parent);

    60 

    61     void propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex);

    62     void propertyRemoved(QtBrowserItem *index);

    63     void propertyChanged(QtBrowserItem *index);

    64     QWidget *createEditor(QtProperty *property, QWidget *parent) const

    65         { return q_ptr->createEditor(property, parent); }

    66 

    67     void slotEditorDestroyed();

    68     void slotUpdate();

    69     void slotToggled(bool checked);

    70 

    71     struct WidgetItem

    72     {

    73         WidgetItem() : widget(0), label(0), widgetLabel(0),

    74                 button(0), container(0), layout(0), /*line(0), */parent(0), expanded(false) { }

    75         QWidget *widget; // can be null

    76         QLabel *label; // main label with property name

    77         QLabel *widgetLabel; // label substitute showing the current value if there is no widget

    78         QToolButton *button; // expandable button for items with children

    79         QWidget *container; // container which is expanded when the button is clicked

    80         QGridLayout *layout; // layout in container

    81         WidgetItem *parent;

    82         QList<WidgetItem *> children;

    83         bool expanded;

    84     };

    85 private:

    86     void updateLater();

    87     void updateItem(WidgetItem *item);

    88     void insertRow(QGridLayout *layout, int row) const;

    89     void removeRow(QGridLayout *layout, int row) const;

    90     int gridRow(WidgetItem *item) const;

    91     int gridSpan(WidgetItem *item) const;

    92     void setExpanded(WidgetItem *item, bool expanded);

    93     QToolButton *createButton(QWidget *panret = 0) const;

    94 

    95     QMap<QtBrowserItem *, WidgetItem *> m_indexToItem;

    96     QMap<WidgetItem *, QtBrowserItem *> m_itemToIndex;

    97     QMap<QWidget *, WidgetItem *> m_widgetToItem;

    98     QMap<QObject *, WidgetItem *> m_buttonToItem;

    99     QGridLayout *m_mainLayout;

   100     QList<WidgetItem *> m_children;

   101     QList<WidgetItem *> m_recreateQueue;

   102 };

   103 

   104 QToolButton *QtButtonPropertyBrowserPrivate::createButton(QWidget *parent) const

   105 {

   106     QToolButton *button = new QToolButton(parent);

   107     button->setCheckable(true);

   108     button->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));

   109     button->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

   110     button->setArrowType(Qt::DownArrow);

   111     button->setIconSize(QSize(3, 16));

   112     /*

   113     QIcon icon;

   114     icon.addPixmap(q_ptr->style()->standardPixmap(QStyle::SP_ArrowDown), QIcon::Normal, QIcon::Off);

   115     icon.addPixmap(q_ptr->style()->standardPixmap(QStyle::SP_ArrowUp), QIcon::Normal, QIcon::On);

   116     button->setIcon(icon);

   117     */

   118     return button;

   119 }

   120 

   121 int QtButtonPropertyBrowserPrivate::gridRow(WidgetItem *item) const

   122 {

   123     QList<WidgetItem *> siblings;

   124     if (item->parent)

   125         siblings = item->parent->children;

   126     else

   127         siblings = m_children;

   128 

   129     int row = 0;

   130     QListIterator<WidgetItem *> it(siblings);

   131     while (it.hasNext()) {

   132         WidgetItem *sibling = it.next();

   133         if (sibling == item)

   134             return row;

   135         row += gridSpan(sibling);

   136     }

   137     return -1;

   138 }

   139 

   140 int QtButtonPropertyBrowserPrivate::gridSpan(WidgetItem *item) const

   141 {

   142     if (item->container && item->expanded)

   143         return 2;

   144     return 1;

   145 }

   146 

   147 void QtButtonPropertyBrowserPrivate::init(QWidget *parent)

   148 {

   149     m_mainLayout = new QGridLayout();

   150     parent->setLayout(m_mainLayout);

   151     QLayoutItem *item = new QSpacerItem(0, 0,

   152                 QSizePolicy::Fixed, QSizePolicy::Expanding);

   153     m_mainLayout->addItem(item, 0, 0);

   154 }

   155 

   156 void QtButtonPropertyBrowserPrivate::slotEditorDestroyed()

   157 {

   158     QWidget *editor = qobject_cast<QWidget *>(q_ptr->sender());

   159     if (!editor)

   160         return;

   161     if (!m_widgetToItem.contains(editor))

   162         return;

   163     m_widgetToItem[editor]->widget = 0;

   164     m_widgetToItem.remove(editor);

   165 }

   166 

   167 void QtButtonPropertyBrowserPrivate::slotUpdate()

   168 {

   169     QListIterator<WidgetItem *> itItem(m_recreateQueue);

   170     while (itItem.hasNext()) {

   171         WidgetItem *item = itItem.next();

   172 

   173         WidgetItem *parent = item->parent;

   174         QWidget *w = 0;

   175         QGridLayout *l = 0;

   176         const int oldRow = gridRow(item);

   177         if (parent) {

   178             w = parent->container;

   179             l = parent->layout;

   180         } else {

   181             w = q_ptr;

   182             l = m_mainLayout;

   183         }

   184 

   185         int span = 1;

   186         if (!item->widget && !item->widgetLabel)

   187             span = 2;

   188         item->label = new QLabel(w);

   189         item->label->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));

   190         l->addWidget(item->label, oldRow, 0, 1, span);

   191 

   192         updateItem(item);

   193     }

   194     m_recreateQueue.clear();

   195 }

   196 

   197 void QtButtonPropertyBrowserPrivate::setExpanded(WidgetItem *item, bool expanded)

   198 {

   199     if (item->expanded == expanded)

   200         return;

   201 

   202     if (!item->container)

   203         return;

   204 

   205     item->expanded = expanded;

   206     const int row = gridRow(item);

   207     WidgetItem *parent = item->parent;

   208     QGridLayout *l = 0;

   209     if (parent)

   210         l = parent->layout;

   211     else

   212         l = m_mainLayout;

   213 

   214     if (expanded) {

   215         insertRow(l, row + 1);

   216         l->addWidget(item->container, row + 1, 0, 1, 2);

   217         item->container->show();

   218     } else {

   219         l->removeWidget(item->container);

   220         item->container->hide();

   221         removeRow(l, row + 1);

   222     }

   223 

   224     item->button->setChecked(expanded);

   225     item->button->setArrowType(expanded ? Qt::UpArrow : Qt::DownArrow);

   226 }

   227 

   228 void QtButtonPropertyBrowserPrivate::slotToggled(bool checked)

   229 {

   230     WidgetItem *item = m_buttonToItem.value(q_ptr->sender());

   231     if (!item)

   232         return;

   233 

   234     setExpanded(item, checked);

   235 

   236     if (checked)

   237         emit q_ptr->expanded(m_itemToIndex.value(item));

   238     else

   239         emit q_ptr->collapsed(m_itemToIndex.value(item));

   240 }

   241 

   242 void QtButtonPropertyBrowserPrivate::updateLater()

   243 {

   244     QTimer::singleShot(0, q_ptr, SLOT(slotUpdate()));

   245 }

   246 

   247 void QtButtonPropertyBrowserPrivate::propertyInserted(QtBrowserItem *index, QtBrowserItem *afterIndex)

   248 {

   249     WidgetItem *afterItem = m_indexToItem.value(afterIndex);

   250     WidgetItem *parentItem = m_indexToItem.value(index->parent());

   251 

   252     WidgetItem *newItem = new WidgetItem();

   253     newItem->parent = parentItem;

   254 

   255     QGridLayout *layout = 0;

   256     QWidget *parentWidget = 0;

   257     int row = -1;

   258     if (!afterItem) {

   259         row = 0;

   260         if (parentItem)

   261             parentItem->children.insert(0, newItem);

   262         else

   263             m_children.insert(0, newItem);

   264     } else {

   265         row = gridRow(afterItem) + gridSpan(afterItem);

   266         if (parentItem)

   267             parentItem->children.insert(parentItem->children.indexOf(afterItem) + 1, newItem);

   268         else

   269             m_children.insert(m_children.indexOf(afterItem) + 1, newItem);

   270     }

   271 

   272     if (!parentItem) {

   273         layout = m_mainLayout;

   274         parentWidget = q_ptr;

   275     } else {

   276         if (!parentItem->container) {

   277             m_recreateQueue.removeAll(parentItem);

   278             WidgetItem *grandParent = parentItem->parent;

   279             QWidget *w = 0;

   280             QGridLayout *l = 0;

   281             const int oldRow = gridRow(parentItem);

   282             if (grandParent) {

   283                 w = grandParent->container;

   284                 l = grandParent->layout;

   285             } else {

   286                 w = q_ptr;

   287                 l = m_mainLayout;

   288             }

   289             QFrame *container = new QFrame();

   290             container->setFrameShape(QFrame::Panel);

   291             container->setFrameShadow(QFrame::Raised);

   292             parentItem->container = container;

   293             parentItem->button = createButton();

   294             m_buttonToItem[parentItem->button] = parentItem;

   295             q_ptr->connect(parentItem->button, SIGNAL(toggled(bool)), q_ptr, SLOT(slotToggled(bool)));

   296             parentItem->layout = new QGridLayout();

   297             container->setLayout(parentItem->layout);

   298             if (parentItem->label) {

   299                 l->removeWidget(parentItem->label);

   300                 delete parentItem->label;

   301                 parentItem->label = 0;

   302             }

   303             int span = 1;

   304             if (!parentItem->widget && !parentItem->widgetLabel)

   305                 span = 2;

   306             l->addWidget(parentItem->button, oldRow, 0, 1, span);

   307             updateItem(parentItem);

   308         }

   309         layout = parentItem->layout;

   310         parentWidget = parentItem->container;

   311     }

   312 

   313     newItem->label = new QLabel(parentWidget);

   314     newItem->label->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));

   315     newItem->widget = createEditor(index->property(), parentWidget);

   316     if (newItem->widget) {

   317         QObject::connect(newItem->widget, SIGNAL(destroyed()), q_ptr, SLOT(slotEditorDestroyed()));

   318         m_widgetToItem[newItem->widget] = newItem;

   319     } else if (index->property()->hasValue()) {

   320         newItem->widgetLabel = new QLabel(parentWidget);

   321         newItem->widgetLabel->setSizePolicy(QSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed));

   322     }

   323 

   324     insertRow(layout, row);

   325     int span = 1;

   326     if (newItem->widget)

   327         layout->addWidget(newItem->widget, row, 1);

   328     else if (newItem->widgetLabel)

   329         layout->addWidget(newItem->widgetLabel, row, 1);

   330     else

   331         span = 2;

   332     layout->addWidget(newItem->label, row, 0, span, 1);

   333 

   334     m_itemToIndex[newItem] = index;

   335     m_indexToItem[index] = newItem;

   336 

   337     updateItem(newItem);

   338 }

   339 

   340 void QtButtonPropertyBrowserPrivate::propertyRemoved(QtBrowserItem *index)

   341 {

   342     WidgetItem *item = m_indexToItem.value(index);

   343 

   344     m_indexToItem.remove(index);

   345     m_itemToIndex.remove(item);

   346 

   347     WidgetItem *parentItem = item->parent;

   348 

   349     const int row = gridRow(item);

   350 

   351     if (parentItem)

   352         parentItem->children.removeAt(parentItem->children.indexOf(item));

   353     else

   354         m_children.removeAt(m_children.indexOf(item));

   355 

   356     const int colSpan = gridSpan(item);

   357 

   358     m_buttonToItem.remove(item->button);

   359 

   360     if (item->widget)

   361         delete item->widget;

   362     if (item->label)

   363         delete item->label;

   364     if (item->widgetLabel)

   365         delete item->widgetLabel;

   366     if (item->button)

   367         delete item->button;

   368     if (item->container)

   369         delete item->container;

   370 

   371     if (!parentItem) {

   372         removeRow(m_mainLayout, row);

   373         if (colSpan > 1)

   374             removeRow(m_mainLayout, row);

   375     } else if (parentItem->children.count() != 0) {

   376         removeRow(parentItem->layout, row);

   377         if (colSpan > 1)

   378             removeRow(parentItem->layout, row);

   379     } else {

   380         const WidgetItem *grandParent = parentItem->parent;

   381         QGridLayout *l = 0;

   382         if (grandParent) {

   383             l = grandParent->layout;

   384         } else {

   385             l = m_mainLayout;

   386         }

   387 

   388         const int parentRow = gridRow(parentItem);

   389         const int parentSpan = gridSpan(parentItem);

   390 

   391         l->removeWidget(parentItem->button);

   392         l->removeWidget(parentItem->container);

   393         delete parentItem->button;

   394         delete parentItem->container;

   395         parentItem->button = 0;

   396         parentItem->container = 0;

   397         parentItem->layout = 0;

   398         if (!m_recreateQueue.contains(parentItem))

   399             m_recreateQueue.append(parentItem);

   400         if (parentSpan > 1)

   401             removeRow(l, parentRow + 1);

   402 

   403         updateLater();

   404     }

   405     m_recreateQueue.removeAll(item);

   406 

   407     delete item;

   408 }

   409 

   410 void QtButtonPropertyBrowserPrivate::insertRow(QGridLayout *layout, int row) const

   411 {

   412     QMap<QLayoutItem *, QRect> itemToPos;

   413     int idx = 0;

   414     while (idx < layout->count()) {

   415         int r, c, rs, cs;

   416         layout->getItemPosition(idx, &r, &c, &rs, &cs);

   417         if (r >= row) {

   418             itemToPos[layout->takeAt(idx)] = QRect(r + 1, c, rs, cs);

   419         } else {

   420             idx++;

   421         }

   422     }

   423 

   424     const QMap<QLayoutItem *, QRect>::ConstIterator icend =  itemToPos.constEnd();

   425     for(QMap<QLayoutItem *, QRect>::ConstIterator it = itemToPos.constBegin(); it != icend; ++it) {

   426         const QRect r = it.value();

   427         layout->addItem(it.key(), r.x(), r.y(), r.width(), r.height());

   428     }

   429 }

   430 

   431 void QtButtonPropertyBrowserPrivate::removeRow(QGridLayout *layout, int row) const

   432 {

   433     QMap<QLayoutItem *, QRect> itemToPos;

   434     int idx = 0;

   435     while (idx < layout->count()) {

   436         int r, c, rs, cs;

   437         layout->getItemPosition(idx, &r, &c, &rs, &cs);

   438         if (r > row) {

   439             itemToPos[layout->takeAt(idx)] = QRect(r - 1, c, rs, cs);

   440         } else {

   441             idx++;

   442         }

   443     }

   444 

   445     const QMap<QLayoutItem *, QRect>::ConstIterator icend =  itemToPos.constEnd();

   446     for(QMap<QLayoutItem *, QRect>::ConstIterator it = itemToPos.constBegin(); it != icend; ++it) {

   447         const QRect r = it.value();

   448         layout->addItem(it.key(), r.x(), r.y(), r.width(), r.height());

   449     }

   450 }

   451 

   452 void QtButtonPropertyBrowserPrivate::propertyChanged(QtBrowserItem *index)

   453 {

   454     WidgetItem *item = m_indexToItem.value(index);

   455 

   456     updateItem(item);

   457 }

   458 

   459 void QtButtonPropertyBrowserPrivate::updateItem(WidgetItem *item)

   460 {

   461     QtProperty *property = m_itemToIndex[item]->property();

   462     if (item->button) {

   463         QFont font = item->button->font();

   464         font.setUnderline(property->isModified());

   465         item->button->setFont(font);

   466         item->button->setText(property->propertyName());

   467         item->button->setToolTip(property->toolTip());

   468         item->button->setStatusTip(property->statusTip());

   469         item->button->setWhatsThis(property->whatsThis());

   470         item->button->setEnabled(property->isEnabled());

   471     }

   472     if (item->label) {

   473         QFont font = item->label->font();

   474         font.setUnderline(property->isModified());

   475         item->label->setFont(font);

   476         item->label->setText(property->propertyName());

   477         item->label->setToolTip(property->toolTip());

   478         item->label->setStatusTip(property->statusTip());

   479         item->label->setWhatsThis(property->whatsThis());

   480         item->label->setEnabled(property->isEnabled());

   481     }

   482     if (item->widgetLabel) {

   483         QFont font = item->widgetLabel->font();

   484         font.setUnderline(false);

   485         item->widgetLabel->setFont(font);

   486         item->widgetLabel->setText(property->valueText());

   487         item->widgetLabel->setToolTip(property->valueText());

   488         item->widgetLabel->setEnabled(property->isEnabled());

   489     }

   490     if (item->widget) {

   491         QFont font = item->widget->font();

   492         font.setUnderline(false);

   493         item->widget->setFont(font);

   494         item->widget->setEnabled(property->isEnabled());

   495         item->widget->setToolTip(property->valueText());

   496     }

   497 }

   498 

   499 

   500 

   501 /*!

   502     \class QtButtonPropertyBrowser

   503     \internal

   504     \inmodule QtDesigner

   505     \since 4.4

   506 

   507     \brief The QtButtonPropertyBrowser class provides a drop down QToolButton

   508     based property browser.

   509 

   510     A property browser is a widget that enables the user to edit a

   511     given set of properties. Each property is represented by a label

   512     specifying the property's name, and an editing widget (e.g. a line

   513     edit or a combobox) holding its value. A property can have zero or

   514     more subproperties.

   515 

   516     QtButtonPropertyBrowser provides drop down button for all nested

   517     properties, i.e. subproperties are enclosed by a container associated with

   518     the drop down button. The parent property's name is displayed as button text. For example:

   519 

   520     \image qtbuttonpropertybrowser.png

   521 

   522     Use the QtAbstractPropertyBrowser API to add, insert and remove

   523     properties from an instance of the QtButtonPropertyBrowser

   524     class. The properties themselves are created and managed by

   525     implementations of the QtAbstractPropertyManager class.

   526 

   527     \sa QtTreePropertyBrowser, QtAbstractPropertyBrowser

   528 */

   529 

   530 /*!

   531     \fn void QtButtonPropertyBrowser::collapsed(QtBrowserItem *item)

   532 

   533     This signal is emitted when the \a item is collapsed.

   534 

   535     \sa expanded(), setExpanded()

   536 */

   537 

   538 /*!

   539     \fn void QtButtonPropertyBrowser::expanded(QtBrowserItem *item)

   540 

   541     This signal is emitted when the \a item is expanded.

   542 

   543     \sa collapsed(), setExpanded()

   544 */

   545 

   546 /*!

   547     Creates a property browser with the given \a parent.

   548 */

   549 QtButtonPropertyBrowser::QtButtonPropertyBrowser(QWidget *parent)

   550     : QtAbstractPropertyBrowser(parent), d_ptr(new QtButtonPropertyBrowserPrivate)

   551 {

   552     d_ptr->q_ptr = this;

   553 

   554     d_ptr->init(this);

   555 }

   556 

   557 /*!

   558     Destroys this property browser.

   559 

   560     Note that the properties that were inserted into this browser are

   561     \e not destroyed since they may still be used in other

   562     browsers. The properties are owned by the manager that created

   563     them.

   564 

   565     \sa QtProperty, QtAbstractPropertyManager

   566 */

   567 QtButtonPropertyBrowser::~QtButtonPropertyBrowser()

   568 {

   569     const QMap<QtButtonPropertyBrowserPrivate::WidgetItem *, QtBrowserItem *>::ConstIterator icend = d_ptr->m_itemToIndex.constEnd();

   570     for (QMap<QtButtonPropertyBrowserPrivate::WidgetItem *, QtBrowserItem *>::ConstIterator  it =  d_ptr->m_itemToIndex.constBegin(); it != icend; ++it)

   571         delete it.key();

   572 }

   573 

   574 /*!

   575     \reimp

   576 */

   577 void QtButtonPropertyBrowser::itemInserted(QtBrowserItem *item, QtBrowserItem *afterItem)

   578 {

   579     d_ptr->propertyInserted(item, afterItem);

   580 }

   581 

   582 /*!

   583     \reimp

   584 */

   585 void QtButtonPropertyBrowser::itemRemoved(QtBrowserItem *item)

   586 {

   587     d_ptr->propertyRemoved(item);

   588 }

   589 

   590 /*!

   591     \reimp

   592 */

   593 void QtButtonPropertyBrowser::itemChanged(QtBrowserItem *item)

   594 {

   595     d_ptr->propertyChanged(item);

   596 }

   597 

   598 /*!

   599     Sets the \a item to either collapse or expanded, depending on the value of \a expanded.

   600 

   601     \sa isExpanded(), expanded(), collapsed()

   602 */

   603 

   604 void QtButtonPropertyBrowser::setExpanded(QtBrowserItem *item, bool expanded)

   605 {

   606     QtButtonPropertyBrowserPrivate::WidgetItem *itm = d_ptr->m_indexToItem.value(item);

   607     if (itm)

   608         d_ptr->setExpanded(itm, expanded);

   609 }

   610 

   611 /*!

   612     Returns true if the \a item is expanded; otherwise returns false.

   613 

   614     \sa setExpanded()

   615 */

   616 

   617 bool QtButtonPropertyBrowser::isExpanded(QtBrowserItem *item) const

   618 {

   619     QtButtonPropertyBrowserPrivate::WidgetItem *itm = d_ptr->m_indexToItem.value(item);

   620     if (itm)

   621         return itm->expanded;

   622     return false;

   623 }

   624 

   625 QT_END_NAMESPACE

   626 

   627 #include "moc_qtbuttonpropertybrowser.cpp"