listmodelbase.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_GUI_MODELS_LISTMODELBASE_H
#define SWIFT_GUI_MODELS_LISTMODELBASE_H
 
#include <memory>
 
#include <QJsonDocument>
#include <QJsonObject>
#include <QModelIndex>
#include <QModelIndexList>
#include <QString>
#include <QVariant>
#include <QVector>
 
#include "gui/models/listmodelbasenontemplate.h"
#include "gui/models/modelfilter.h"
#include "gui/models/selectionmodel.h"
 
class QMimeData;
class QModelIndex;
 
namespace swift::misc
{
    class CWorker;
}
namespace swift::gui::models
{
    template <typename T, bool UseCompare = false>
    class CListModelBase : public CListModelBaseNonTemplate
    {
    public:
        using ContainerType = T;
 
        using ObjectType = typename T::value_type;
 
        ~CListModelBase() override = default;
 
 
        QVariant data(const QModelIndex &index, int role) const override;
 
        bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) final;
 
        QMimeData *mimeData(const QModelIndexList &indexes) const final;
 
        void sort(int column, Qt::SortOrder order) final;
 
        int rowCount(const QModelIndex &parentIndex = QModelIndex()) const final;
 
        bool canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column,
                             const QModelIndex &parent) const final;
 
        bool dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int row, int column,
                          const QModelIndex &parent) final;
 
 
        QJsonObject toJson(bool selectedOnly = false) const override;
 
        QString toJsonString(QJsonDocument::JsonFormat format = QJsonDocument::Indented,
                             bool selectedOnly = false) const override;
 
        bool isOrderable() const override;
 
        virtual bool isValidIndex(const QModelIndex &index) const;
 
        const ContainerType &container() const;
 
        const ContainerType &containerFiltered() const;
 
        const ContainerType &containerOrFilteredContainer(bool *filtered = nullptr) const;
 
        bool setInContainer(const QModelIndex &index, const ObjectType &obj);
 
        virtual int update(const ContainerType &container, bool sort = true);
 
        virtual swift::misc::CWorker *updateAsync(const ContainerType &container, bool sort = true);
 
        virtual void updateContainerMaybeAsync(const ContainerType &container, bool sort = true);
 
        virtual void update(const QModelIndex &index, const ObjectType &object);
 
        virtual void update(int rowIndex, const ObjectType &object);
 
        virtual void moveItems(const ContainerType &items, int position);
 
        virtual const ObjectType &at(const QModelIndex &index) const;
 
        void sort();
 
        void resort();
 
        void truncate(int maxNumber, bool forceSort = false);
 
        ContainerType sortContainerByColumn(const ContainerType &container, int column, Qt::SortOrder order) const;
 
        virtual void push_back(const ObjectType &object);
 
        virtual void push_back(const ContainerType &container);
 
        virtual void insert(const ObjectType &object);
 
        virtual void insert(const ContainerType &container);
 
        virtual void remove(const ObjectType &object);
 
        template <class K0, class V0, class... KeysValues>
        int removeIf(K0 k0, V0 v0, KeysValues... keysValues)
        {
            int c = m_container.removeIf(swift::misc::predicates::MemberEqual(k0, v0, keysValues...));
            this->updateFilteredContainer();
            if (c > 0) { this->emitModelDataChanged(); }
            return c;
        }
 
        virtual void clear();
 
        virtual bool isEmpty() const;
 
        bool hasFilter() const;
 
        void removeFilter();
 
        void takeFilterOwnership(std::unique_ptr<IModelFilter<ContainerType>> &filter);
 
        void setSelectionModel(swift::gui::models::ISelectionModel<ContainerType> *selectionModel)
        {
            m_selectionModel = selectionModel;
        }
 
    protected:
        CListModelBase(const QString &translationContext, QObject *parent = nullptr);
 
 
        void onDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomLeft,
                           const QVector<int> &roles) override;
 
        void onChangedDigest() override;
 
        void updateFilteredContainer();
 
        void emitModelDataChanged();
 
        ContainerType m_container; 
        ContainerType m_containerFiltered; 
        std::unique_ptr<IModelFilter<ContainerType>> m_filter; 
        ISelectionModel<ContainerType> *m_selectionModel = nullptr; 
    };
 
    namespace Private
    {
        template <class ObjectType>
        bool compareForModelSort(const ObjectType &a, const ObjectType &b, Qt::SortOrder order,
                                 const swift::misc::CPropertyIndex &index,
                                 const swift::misc::CPropertyIndexList &tieBreakers, std::true_type)
        {
            const int c = a.comparePropertyByIndex(index, b);
            if (c == 0)
            {
                if (!tieBreakers.isEmpty())
                {
                    return compareForModelSort<ObjectType>(a, b, order, tieBreakers.front(),
                                                           tieBreakers.copyFrontRemoved(), std::true_type());
                }
                return false;
            }
            return (order == Qt::AscendingOrder) ? (c < 0) : (c > 0);
        }
 
        template <typename ObjectType>
        bool compareForModelSort(const ObjectType &a, const ObjectType &b, Qt::SortOrder order,
                                 const swift::misc::CPropertyIndex &index,
                                 const swift::misc::CPropertyIndexList &tieBreakers, std::false_type)
        {
            const swift::misc::CVariant aQv = a.propertyByIndex(index);
            const swift::misc::CVariant bQv = b.propertyByIndex(index);
            if (!tieBreakers.isEmpty() && aQv == bQv)
            {
                return compareForModelSort<ObjectType>(a, b, order, tieBreakers.front(), tieBreakers.copyFrontRemoved(),
                                                       std::false_type());
            }
            return (order == Qt::AscendingOrder) ? (aQv < bQv) : (bQv < aQv);
        }
    } // namespace Private
} // namespace swift::gui::models
 
#endif // SWIFT_GUI_MODELS_LISTMODELBASE_H