text: /****************************************************************************
  **
  ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
  ** Contact: http://www.qt-project.org/legal
  **
  ** 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 Digia.  For licensing terms and
  ** conditions see http://qt.digia.com/licensing.  For further information
  ** use the contact form at http://qt.digia.com/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 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, Digia gives you certain additional
  ** rights.  These rights are described in the Digia Qt LGPL Exception
  ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  **
  ** GNU General Public License Usage
  ** Alternatively, this file may be used under the terms of the GNU
  ** General Public License version 3.0 as published by the Free Software
  ** Foundation and appearing in the file LICENSE.GPL included in the
  ** packaging of this file.  Please review the following information to
  ** ensure the GNU General Public License version 3.0 requirements will be
  ** met: http://www.gnu.org/copyleft/gpl.html.
  **
  **
  ** $QT_END_LICENSE$
  **
  ****************************************************************************/
  
  #include "qtbuttonpropertybrowser.h"
  #include <QtCore/QSet>
  #include <QtWidgets/QGridLayout>
  #include <QtWidgets/QLabel>
  #include <QtCore/QTimer>
  #include <QtCore/QMap>
  #include <QtWidgets/QToolButton>
  #include <QtWidgets/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;
              QGridLayout *l = 0;
              const int oldRow = gridRow(parentItem);
              if (grandParent) {
                  l = grandParent->layout;
              } else {
                  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"
  