ItemStackPresenter now can use same widget for item presentation.

GUI/coregui/Views/CommonWidgets/ItemStackPresenter.h

@@ -26,84 +26,106 @@ class SessionItem;
 //! The ItemStackPresenter templated class extends ItemStackWidget so it could operate with
 //! SesionItem editor's of specified type, while still keeping signal/slots alive.
 
-template<class T>
-class BA_CORE_API_ ItemStackPresenter : public ItemStackWidget
+template <class T> class BA_CORE_API_ ItemStackPresenter : public ItemStackWidget
 {
 public:
+    ItemStackPresenter(bool single_widget = false) : m_single_widget(single_widget){}
 
-    virtual void setItem(SessionItem *item, bool &isNew) {
-        validateItem(item);
+    virtual void setItem(SessionItem* item, bool& isNew);
 
-        isNew = false;
-        if(!item) {
-            hideWidgets();
-            return;
-        }
+    T* currentWidget();
+    T* itemWidget(SessionItem* item);
+    void hideWidgets();
 
-        T *widget = m_itemToWidget[item];
+protected:
+    void removeWidgetForItem(SessionItem* item);
+    void removeWidgets();
 
-        if(!widget) {
-            widget = new T();
-            isNew = true;
-            m_stackedWidget->addWidget(widget);
-            m_itemToWidget[item] = widget;
-        }
-        Q_ASSERT(widget);
-        m_stackedWidget->setCurrentWidget(widget);
-        if(widget->isHidden())
-            widget->show();
+private:
+    QMap<SessionItem*, T*> m_itemToWidget;
+    bool m_single_widget; //!< Different items will be served by same widget
+};
 
-    }
+template <class T>
+void ItemStackPresenter<T>::setItem(SessionItem* item, bool& isNew)
+{
+    validateItem(item);
 
-    T *currentWidget() {
-        return dynamic_cast<T *>(m_stackedWidget->currentWidget());
+    isNew = false;
+    if (!item) {
+        hideWidgets();
+        return;
     }
 
-    T *itemWidget(SessionItem *item) {
-        return m_itemToWidget[item];
-    }
+    T* widget = itemWidget(item);
 
-    void hideWidgets() {
-        if(m_stackedWidget->currentWidget()) {
-            m_stackedWidget->currentWidget()->hide();
-        }
+    if (!widget) {
+        widget = new T();
+        isNew = true;
+        m_stackedWidget->addWidget(widget);
+        m_itemToWidget[item] = widget;
     }
 
-protected:
-    void removeWidgetForItem(SessionItem *item) {
-        Q_ASSERT(item);
+    m_stackedWidget->setCurrentWidget(widget);
+    if (widget->isHidden())
+        widget->show();
+}
+
+template <class T>
+T* ItemStackPresenter<T>::currentWidget() {
+    return dynamic_cast<T*>(m_stackedWidget->currentWidget());
+}
 
-        T *widget = m_itemToWidget[item];
-        if(!widget) return;
+template <class T>
+T* ItemStackPresenter<T>::itemWidget(SessionItem* item)
+{
+    if(m_single_widget) {
+        if(m_itemToWidget.size())
+            return m_itemToWidget.first();
+    } else {
+        return m_itemToWidget[item];
+    }
 
-        typename QMap<SessionItem *, T *>::iterator it = m_itemToWidget.begin();
-        while(it!=m_itemToWidget.end()) {
-            if(it.value() == widget) {
-                it = m_itemToWidget.erase(it);
-            } else {
-                ++it;
-            }
-        }
+    return nullptr;
+}
 
-        m_stackedWidget->removeWidget(widget);
-        delete widget;
+template <class T>
+void ItemStackPresenter<T>::hideWidgets() {
+    if (m_stackedWidget->currentWidget())
+        m_stackedWidget->currentWidget()->hide();
+}
 
+template <class T>
+void ItemStackPresenter<T>::removeWidgetForItem(SessionItem* item)
+{
+    Q_ASSERT(item);
 
-    }
+    T* widget = m_itemToWidget[item];
+    if (!widget)
+        return;
 
-    void removeWidgets() {
-        typename QMap<SessionItem *, T *>::iterator it = m_itemToWidget.begin();
-        while(it!=m_itemToWidget.end()) {
-            m_stackedWidget->removeWidget(it.value());
-            delete it.value();
+    typename QMap<SessionItem*, T*>::iterator it = m_itemToWidget.begin();
+    while (it != m_itemToWidget.end()) {
+        if (it.value() == widget)
+            it = m_itemToWidget.erase(it);
+        else
             ++it;
-        }
-        m_itemToWidget.clear();
     }
 
-private:
-    QMap<SessionItem *, T *> m_itemToWidget;
-};
+    m_stackedWidget->removeWidget(widget);
+    delete widget;
+}
 
+template <class T>
+void ItemStackPresenter<T>::removeWidgets()
+{
+    typename QMap<SessionItem*, T*>::iterator it = m_itemToWidget.begin();
+    while (it != m_itemToWidget.end()) {
+        m_stackedWidget->removeWidget(it.value());
+        delete it.value();
+        ++it;
+    }
+    m_itemToWidget.clear();
+}
 
 #endif // ITEMSTACKPRESENTER_H

GUI/coregui/Views/CommonWidgets/ItemStackWidget.cpp

@@ -20,27 +20,26 @@
 #include <QStackedWidget>
 #include <QVBoxLayout>
 
-
-ItemStackWidget::ItemStackWidget(QWidget *parent)
+ItemStackWidget::ItemStackWidget(QWidget* parent)
     : QWidget(parent)
     , m_stackedWidget(new QStackedWidget)
-    , m_model(0)
+    , m_model(nullptr)
     , m_size_hint(QSize(1024, 1024))
 {
     setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     m_stackedWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
-    QVBoxLayout *layout = new QVBoxLayout;
+    QVBoxLayout* layout = new QVBoxLayout;
     layout->setMargin(0);
     layout->setSpacing(0);
-    layout->setContentsMargins(0,0,0,0);
+    layout->setContentsMargins(0, 0, 0, 0);
     layout->addWidget(m_stackedWidget);
     setLayout(layout);
 }
 
-void ItemStackWidget::setModel(SessionModel *model)
+void ItemStackWidget::setModel(SessionModel* model)
 {
-    if(model == m_model)
+    if (model == m_model)
         return;
 
     disconnectModel();
@@ -58,7 +57,7 @@ QSize ItemStackWidget::minimumSizeHint() const
     return QSize(25, 25);
 }
 
-void ItemStackWidget::setSizeHint(const QSize &size_hint)
+void ItemStackWidget::setSizeHint(const QSize& size_hint)
 {
     m_size_hint = size_hint;
 }
@@ -68,55 +67,53 @@ void ItemStackWidget::onModelAboutToBeReset()
     removeWidgets();
 }
 
-void ItemStackWidget::onRowsAboutToBeRemoved(const QModelIndex &parent, int first, int)
+void ItemStackWidget::onRowsAboutToBeRemoved(const QModelIndex& parent, int first, int)
 {
-    SessionItem *item = m_model->itemForIndex(m_model->index(first, 0, parent));
+    SessionItem* item = m_model->itemForIndex(m_model->index(first, 0, parent));
     removeWidgetForItem(item);
 }
 
-void ItemStackWidget::onSelectionChanged(SessionItem *item)
+void ItemStackWidget::onSelectionChanged(SessionItem* item)
 {
     bool isNew(false);
     setItem(item, isNew);
 }
 
-
 void ItemStackWidget::connectModel()
 {
-    if(!m_model) return;
+    if (!m_model)
+        return;
 
-    connect(m_model, SIGNAL(modelAboutToBeReset()),
-            this, SLOT(onModelAboutToBeReset()),
+    connect(m_model, SIGNAL(modelAboutToBeReset()), this, SLOT(onModelAboutToBeReset()),
             Qt::UniqueConnection);
 
-    connect(m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int,int)),
-            this, SLOT(onRowsAboutToBeRemoved(QModelIndex,int,int)),
-            Qt::UniqueConnection);
+    connect(m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)), this,
+            SLOT(onRowsAboutToBeRemoved(QModelIndex, int, int)), Qt::UniqueConnection);
 }
 
 void ItemStackWidget::disconnectModel()
 {
-    if(!m_model) return;
+    if (!m_model)
+        return;
 
-    disconnect(m_model, SIGNAL(modelAboutToBeReset()),
-            this, SLOT(onModelAboutToBeReset()));
+    disconnect(m_model, SIGNAL(modelAboutToBeReset()), this, SLOT(onModelAboutToBeReset()));
 
-    disconnect(m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int,int)),
-               this, SLOT(onRowsAboutToBeRemoved(QModelIndex,int,int)));
+    disconnect(m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)), this,
+               SLOT(onRowsAboutToBeRemoved(QModelIndex, int, int)));
 }
 
 //! Checks if model was set correctly.
 
-void ItemStackWidget::validateItem(SessionItem *item)
+void ItemStackWidget::validateItem(SessionItem* item)
 {
-    if(!item) return;
+    if (!item)
+        return;
 
-    if(m_model) {
-        if(m_model != item->model()) {
+    if (m_model) {
+        if (m_model != item->model())
             // in principle it should be possible, but should be tested
             throw GUIHelpers::Error("ItemStackWidget::validateItem() -> Error. "
                                     "Attempt to use items from different models.");
-        }
     } else {
         setModel(item->model());
     }

GUI/coregui/Views/CommonWidgets/ItemStackWidget.h

@@ -35,33 +35,33 @@ class BA_CORE_API_ ItemStackWidget : public QWidget
     Q_OBJECT
 
 public:
-    ItemStackWidget(QWidget *parent = 0);
+    ItemStackWidget(QWidget* parent = 0);
 
-    void setModel(SessionModel *model);
+    void setModel(SessionModel* model);
 
     //! Shows the widget for given item (and hides previous one).
     //! If no widget yet exists, it will be created (flag isNew will become 'true' in this case).
-    virtual void setItem(SessionItem *item, bool &isNew) = 0;
+    virtual void setItem(SessionItem* item, bool& isNew) = 0;
 
     QSize sizeHint() const;
     QSize minimumSizeHint() const;
 
-    void setSizeHint(const QSize &size_hint);
+    void setSizeHint(const QSize& size_hint);
 
 public slots:
     virtual void onModelAboutToBeReset();
-    virtual void onRowsAboutToBeRemoved(const QModelIndex &parent,int first,int);
-    virtual void onSelectionChanged(SessionItem *item);
+    virtual void onRowsAboutToBeRemoved(const QModelIndex& parent, int first, int);
+    virtual void onSelectionChanged(SessionItem* item);
 
 protected:
     void connectModel();
     void disconnectModel();
-    void validateItem(SessionItem *item);
-    virtual void removeWidgetForItem(SessionItem *item) = 0;
+    void validateItem(SessionItem* item);
+    virtual void removeWidgetForItem(SessionItem* item) = 0;
     virtual void removeWidgets() = 0;
 
-    class QStackedWidget *m_stackedWidget;
-    SessionModel *m_model;
+    class QStackedWidget* m_stackedWidget;
+    SessionModel* m_model;
     QSize m_size_hint;
 };