SessionModel.h

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Model/SessionModel.h
//! @brief     Defines class SessionModel
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#ifndef BORNAGAIN_GUI_MODEL_MODEL_SESSIONMODEL_H
#define BORNAGAIN_GUI_MODEL_MODEL_SESSIONMODEL_H
 
#include "GUI/Model/BaseItem/SessionItem.h"
#include <QStringList>
#include <QVariant>
#include <QXmlStreamWriter> // used in every including file ?
#include <heinz/Complex.h>
#include <heinz/Vectors3D.h>
 
class MessageService;
 
//! Base class for a GUI data collection.
//! A collection is e.g. all real data (RealDataModel).
//! Every model is implementing a Qt item model, therefore
//! the "model" in the class name.
//! Each model is populated by objects derived from SessionItem.
//!
//! Purpose of a model is to
//! * Keep the root item of the contained data (which then keeps the tree of all
//!   items in this model)
//! * adding/removing items
//! * iteration over contained items
//! * load/store the items in the project file as XML
//! * use Qt mechanisms for GUI representation in different views
//! * notification of data changes to any listener
 
class SessionModel : public QAbstractItemModel {
    Q_OBJECT
    friend class SessionItem;
 
public:
    explicit SessionModel(QString model_tag, QObject* parent = nullptr);
    ~SessionModel() override;
    void createRootItem();
 
    // Begin overridden methods from QAbstractItemModel
    Qt::ItemFlags flags(const QModelIndex& index) const override;
    QVariant data(const QModelIndex& index, int role) const override;
    QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
    int rowCount(const QModelIndex& parent) const override;
    int columnCount(const QModelIndex& parent) const override;
    QModelIndex index(int row, int column, const QModelIndex& parent) const override;
    QModelIndex parent(const QModelIndex& child) const override;
 
    bool setData(const QModelIndex& index, const QVariant& value, int role) override;
    bool removeRows(int row, int count, const QModelIndex& parent) override;
 
    Qt::DropActions supportedDragActions() const override;
    Qt::DropActions supportedDropActions() const override;
    QStringList mimeTypes() const override;
    QMimeData* mimeData(const QModelIndexList& indices) const override;
    bool canDropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column,
                         const QModelIndex& parent) const override;
    bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column,
                      const QModelIndex& parent) override;
    // End overridden methods from QAbstractItemModel
 
    QModelIndex indexOfItem(SessionItem* item) const;
    SessionItem* insertNewItem(QString model_type, SessionItem* parent_item = nullptr, int row = -1,
                               QString tag = "");
 
    // #migration Method is deprecated, index usage is discouraged.
    SessionItem* insertNewItem(QString model_type, const QModelIndex& parent_item, int row = -1,
                               QString tag = "");
 
    template <typename T>
    T* insertItem(SessionItem* parent = nullptr, int row = -1, QString tag = "");
 
    // #migration Method is deprecated, index usage is discouraged.
    template <typename T>
    T* insertItem(const QModelIndex& parent, int row = -1, QString tag = "");
 
    void removeItem(SessionItem* item);
 
    QString getModelTag() const;
 
    QVector<QString> acceptableDefaultItemTypes(const QModelIndex& parent) const;
 
    virtual void clear();
 
    // Sets mimedata pointer of item being dragged
    void setDraggedItemType(const QString& type);
 
    // Returns root item if index is not valid
    SessionItem* itemForIndex(const QModelIndex& index) const;
 
    virtual void readFrom(QXmlStreamReader* reader, MessageService* messageService = nullptr);
    virtual void writeTo(QXmlStreamWriter* writer);
 
    SessionItem* moveItem(SessionItem* item, SessionItem* new_parent = nullptr, int row = -1,
                          const QString& tag = "");
 
    template <typename T>
    T* copyItem(const T* item_to_copy, SessionItem* new_parent = nullptr, const QString& tag = "");
 
    SessionItem* copy(const SessionItem* item_to_copy, SessionItem* new_parent = nullptr,
                      const QString& tag = "");
 
    //! Returns first item in list of topItems
    template <typename T = SessionItem>
    T* topItem() const;
    template <typename T = SessionItem>
    QVector<T*> topItems() const;
    template <typename T = SessionItem>
    QVector<T*> topItems(std::function<bool(const T&)> accept) const;
 
    virtual void initFrom(SessionModel* model, SessionItem* parent);
    SessionItem* rootItem() const;
 
    virtual QVector<SessionItem*> nonXMLItems() const;
 
protected:
    void setRootItem(SessionItem* root) { m_root_item = root; }
 
private:
    SessionItem* m_root_item;
    QString m_dragged_item_type;
    QString m_model_tag;
};
 
template <typename T>
T* SessionModel::insertItem(SessionItem* parent, int row, QString tag)
{
    return dynamic_cast<T*>(insertNewItem(T().modelType(), parent, row, tag));
}
 
template <typename T>
T* SessionModel::insertItem(const QModelIndex& parent, int row, QString tag)
{
    return insertItem<T>(itemForIndex(parent), row, tag);
}
 
template <typename T>
T* SessionModel::copyItem(const T* item_to_copy, SessionItem* new_parent, const QString& tag)
{
    return static_cast<T*>(copy(item_to_copy, new_parent, tag));
}
 
template <typename T>
T* SessionModel::topItem() const
{
    auto items = topItems<T>();
    return items.isEmpty() ? nullptr : items.front();
}
 
template <typename T>
QVector<T*> SessionModel::topItems() const
{
    QVector<T*> result;
 
    QModelIndex parentIndex;
    for (int i_row = 0; i_row < rowCount(parentIndex); ++i_row) {
        QModelIndex itemIndex = index(i_row, 0, parentIndex);
        if (auto item = dynamic_cast<T*>(itemForIndex(itemIndex)))
            result.push_back(item);
    }
 
    return result;
}
 
template <typename T>
QVector<T*> SessionModel::topItems(std::function<bool(const T&)> accept) const
{
    QVector<T*> result;
 
    QModelIndex parentIndex;
    for (int i_row = 0; i_row < rowCount(parentIndex); ++i_row) {
        QModelIndex itemIndex = index(i_row, 0, parentIndex);
        if (auto item = dynamic_cast<T*>(itemForIndex(itemIndex)))
            if (accept(*item))
                result.push_back(item);
    }
 
    return result;
}
 
inline Qt::DropActions SessionModel::supportedDragActions() const
{
    return Qt::MoveAction;
}
 
inline Qt::DropActions SessionModel::supportedDropActions() const
{
    return Qt::MoveAction;
}
 
inline QString SessionModel::getModelTag() const
{
    return m_model_tag;
}
 
inline void SessionModel::setDraggedItemType(const QString& type)
{
    m_dragged_item_type = type;
}
 
#endif // BORNAGAIN_GUI_MODEL_MODEL_SESSIONMODEL_H