itemhandler.h

/* mathvizanimator
 * Copyright (C) 2023 codingwithmagga
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef LIBS_MVA_WORKFLOW_INCLUDE_WORKFLOW_ITEMHANDLER_H_
#define LIBS_MVA_WORKFLOW_INCLUDE_WORKFLOW_ITEMHANDLER_H_
 
#include <QItemSelectionModel>
#include <QObject>
#include <QQuickItem>
#include <QStandardItemModel>
 
#include "basic_item.h"
#include "item_observer.h"
 
class ItemModelItem;
 
struct ItemProperty {
    QString name;
    QVariant value;
};
 
class PropertyModel : public QStandardItemModel {
  public:
    void appendProperty(const ItemProperty& property);
 
    void appendProperties(const PropertyMap& properties);
 
    Qt::ItemFlags flags(const QModelIndex& index) const override;
};
 
class ItemHandler : public QObject {
    Q_OBJECT
 
  public:
    enum ItemRoles { ITEM_OBSERVER = Qt::UserRole + 1 };
 
    explicit ItemHandler(QObject* parent = nullptr);
 
    qsizetype numItems() const { return m_item_model.rowCount(); }
    QStandardItemModel* model() { return &m_item_model; }
    QItemSelectionModel* selectionModel() { return &m_item_selection_model; }
    PropertyModel* propertyModel() { return &m_property_model; }
    QStandardItemModel* animationModel() { return &m_animation_model; }
    QList<BasicItem*> basicItems();
    QList<QSharedPointer<ItemObserver>> items();
 
    void scaleItems(const qreal width_ratio, const qreal height_ratio);
 
  public slots:
    void clear();
 
    void addItem(BasicItem* const basic_item);
    void removeItem(BasicItem* const basic_item);
    void setCurrentItem(const QString& itemName);
    void removeCurrentItem();
 
    void addAnimation(
        const QString& item_name, const QString& animation_type, const qreal start_time, const qreal duration);
    void addAnimations(const QString& item_name, const QList<QSharedPointer<AbstractAnimation>> animations);
    void removeAnimation(const qint32 animation_number);
 
    void setTime(const qreal time);
    void changeProperty(const QString& item_name, const QByteArray& property, const QVariant& value);
 
  private slots:
    void propertyDataChanged(
        const QModelIndex& topLeft, const QModelIndex& bottomRight, const QList<qint32>& roles = QList<qint32>());
    void currentItemChanged(const QModelIndex& current, const QModelIndex& previous);
 
  private:
    struct ItemExtract {
        AbstractItem* item;
        bool error;
    };
 
    bool itemAlreadyExists(BasicItem* const basic_item);
    bool itemNameAlreadyExists(const QString& name);
 
    QString prepareNewItemName(const QString& old_item_name);
 
    void repopulatePropertyModel(const QModelIndex& currentIndex);
    void repopulateAnimationModel(const ItemModelItem* const item);
 
    void setDeleteEachQuickItem(QModelIndex parent = QModelIndex());
 
    ItemModelItem* getItemModelItemByName(const QString& item_name);
    QSharedPointer<ItemObserver> getItemObserverByName(const QString& item_name);
 
    void prepareModelHeader();
    void updateItemModelName(const QVariant& name);
 
    QStandardItemModel m_item_model;
    QStandardItemModel m_animation_model;
    QItemSelectionModel m_item_selection_model;
 
    PropertyModel m_property_model;
};
 
class ItemModelItem : public QStandardItem {
  public:
    explicit ItemModelItem(const QString& text);
 
    ~ItemModelItem();
 
    void setDeleteQuickitem(const bool delete_quick_item) { m_delete_quick_item = delete_quick_item; }
 
    QSharedPointer<ItemObserver> itemObserver() const;
    void setItemObserver(const QSharedPointer<ItemObserver>& new_item_observer);
 
  private:
    /*
     * This variable is necessary to determine if the (possibly) containing
     * QQuickItem should be deleted or not. If the user deletes the item it should
     * be set to true, to remove the item from the GUI. If the app gets closed,
     * everything gets automatically deleted from the GUI and this variable should
     * be set (or keeped) false. This is because in some cases both the GUI and
     * the deconstructor of this class seems to try to delete the item
     * simultaneously. This leads to a segmentation fault.
     *
     * I'm not really happy with this solution, because current extensions could
     * break this workflow. This should be done automatically.
     *
     * TODO(codingwithmagga): GUI deletes the QQuickItem. The QQuickItem or
     * better the containing AbstractItem should emit a signal or sth. similar
     * when they get destroyed. Then this ItemModelItem should removed. So it
     * goes the other way around. Not sure if this solves the problem when
     * shutting down the app.
     */
    bool m_delete_quick_item = false;
 
    QSharedPointer<ItemObserver> m_item_observer;
};
 
#endif // LIBS_MVA_WORKFLOW_INCLUDE_WORKFLOW_ITEMHANDLER_H_