GroupedItemsProxyModel.h

Go to the documentation of this file.

/*
  GroupedItemsProxyModel
  https://github.com/mpaperno/maxLibQt

  COPYRIGHT: (c)2017 Maxim Paperno; All Right Reserved.
  Contact: http://www.WorldDesign.com/contact

  LICENSE:

  Commercial License Usage
  Licensees holding valid commercial licenses may use this file in
  accordance with the terms contained in a written agreement between
  you and the copyright holder.

  GNU General Public License Usage
  Alternatively, this file may be used 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.

  A copy of the GNU General Public License is available at <http://www.gnu.org/licenses/>.
*/

#ifndef GROUPEDITEMSPROXYMODEL_H
#define GROUPEDITEMSPROXYMODEL_H

#include <QIdentityProxyModel>
#include <QSize>
#include <QDebug>
#include <QMetaMethod>

class GroupedItemsProxyModel : public QIdentityProxyModel
{
    Q_OBJECT
    Q_PROPERTY(int groupMatchRole READ groupMatchRole WRITE setGroupMatchRole)
    Q_PROPERTY(bool groupColumnVisible READ groupColumnVisible WRITE setGroupColumnVisible)
    Q_PROPERTY(bool groupColumnIsProxy READ groupColumnIsProxy WRITE setGroupColumnIsProxy)
    Q_PROPERTY(int groupColumnProxySrc READ groupColumnProxySrc WRITE setGroupColumnProxySrc)
    Q_PROPERTY(bool groupRowSelectable READ groupRowSelectable WRITE setGroupRowSelectable)
    Q_PROPERTY(QString groupHeaderTitle READ groupHeaderTitle WRITE setGroupHeaderTitle)
    Q_PROPERTY (int count READ count NOTIFY countChanged)

  public:
    enum { SourceRowNumberRole = Qt::UserRole - 5 };

    explicit GroupedItemsProxyModel(QObject *parent = Q_NULLPTR, QAbstractItemModel *sourceModel = Q_NULLPTR, const QVector<int> &groupColumns = QVector<int>());
    ~GroupedItemsProxyModel();

    // QAbstractItemModel interface
    void setSourceModel(QAbstractItemModel *newSourceModel) Q_DECL_OVERRIDE;
    QModelIndex index(int row, int column, const QModelIndex &parent) const Q_DECL_OVERRIDE;
    QModelIndex parent(const QModelIndex &child) const Q_DECL_OVERRIDE;
    int rowCount(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
    int columnCount(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
    bool hasChildren(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
    QVariant data(const QModelIndex &index, int role = Qt::EditRole) const Q_DECL_OVERRIDE;
    QMap<int, QVariant> itemData(const QModelIndex &index) const Q_DECL_OVERRIDE;
    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const Q_DECL_OVERRIDE;
    Qt::ItemFlags flags(const QModelIndex &index) const Q_DECL_OVERRIDE;
    QSize span(const QModelIndex &index) const Q_DECL_OVERRIDE;
    QHash<int, QByteArray> roleNames() const;

    // QAbstractProxyModel interface
    QModelIndex mapToSource(const QModelIndex &proxyIndex) const Q_DECL_OVERRIDE;
    QModelIndex mapFromSource(const QModelIndex &sourceIndex) const Q_DECL_OVERRIDE;

    // Qml API
    inline int count() { return rowCount(); }
    Q_INVOKABLE void move (int idx, int pos, int parent = -1);

    Q_INVOKABLE int mapToSourceRow(int idx)   const { return mapToSource(index(idx, 0, indexForItem(m_defaultParent))).row(); }
    Q_INVOKABLE int mapFromSourceRow(int idx) const { return mapFromSource(sourceModel()->index(idx, 0)).row(); }

    Q_INVOKABLE QObject *get (int idx) const {
      const static int getIdx = sourceModel()->metaObject()->indexOfMethod(QMetaObject::normalizedSignature("get(int)"));
      if (getIdx > -1) {
        QObject *ret;
        sourceModel()->metaObject()->invokeMethod(sourceModel(), "get", Qt::DirectConnection, Q_RETURN_ARG(QObject *, ret), Q_ARG(int, mapToSourceRow(idx)));
        return ret;
      }
      qWarning() << "Can't get(int), source model not compatible";
      return nullptr;
    }

    Q_INVOKABLE QObject *get (const QString &uid) const {
      const static int getIdx = sourceModel()->metaObject()->indexOfMethod(QMetaObject::normalizedSignature("get(QString)"));
      if (getIdx > -1) {
        QObject *ret;
        sourceModel()->metaObject()->invokeMethod(sourceModel(), "get", Qt::DirectConnection, Q_RETURN_ARG(QObject *, ret), Q_ARG(const QString &, uid));
        return ret;
      }
      qWarning() << "Can't get(QString), source model not compatible";
      return nullptr;
    }

    // GroupedItemProxyModel interface

    inline int groupMatchRole() const { return m_groupMatchRole; }
    inline int groupColumnVisible() const { return m_groupColumnVisible; }
    inline int groupColumnIsProxy() const { return m_groupColumnIsProxy; }
    inline int groupColumnProxySrc() const { return m_groupColumnProxySrc; }
    inline int groupRowSelectable() const { return m_groupRowSelectable; }
    inline QString groupHeaderTitle() const { return m_root->data(Qt::DisplayRole).toString(); }

  signals:
    void countChanged();

  public slots:
    inline void addGroup(int column) { addGroups(QVector<int>() << column); }
    virtual void addGroups(const QVector<int> & columns);
    virtual void setGroups(const QVector<int> & columns);
    virtual void insertGroup(int index, int column);
    virtual void removeGroup(int column);
    virtual void clearGroups();
    virtual void setRootGroup(int column = -1, const QVariant &value = QVariant());
    // properties
    virtual void setGroupMatchRole(int role);
    virtual void setGroupColumnVisible(bool visible) { m_groupColumnVisible = visible; }
    virtual void setGroupColumnIsProxy(bool enable)  { m_groupColumnIsProxy = enable; }
    virtual void setGroupColumnProxySrc(int column) { m_groupColumnProxySrc = column; }
    virtual void setGroupRowSelectable(bool selectable) { m_groupRowSelectable = selectable; }
    virtual void setGroupHeaderTitle(const QString &title, const QString &tooltip = QString());

  protected:
    class GroupedProxyItem;  // forward

    virtual uint extraColumns() const { return (!m_groups.isEmpty() && groupColumnVisible() ? 1 : 0); }
    virtual QModelIndex indexForItem(GroupedProxyItem *item, const int col = 0) const;
    virtual GroupedProxyItem * itemForIndex(const QModelIndex &index, const bool rootDefault = false) const;
    virtual GroupedProxyItem * findGroupItem(const int group, const QVariant &value = QVariant(), GroupedProxyItem *parent = NULL) const;
    virtual QModelIndex sourceIndexForProxy(GroupedProxyItem *item) const;
    virtual bool isProxyColumn(const QModelIndex &index) const { return (index.isValid() && extraColumns() && index.column() == 0 && groupColumnIsProxy()); }
    int totalRowCount(GroupedProxyItem *parent = NULL) const;
    GroupedProxyItem * itemForRow(int row, GroupedProxyItem *parent = NULL) const;

  protected slots:
    virtual GroupedProxyItem * placeSourceRow(const int row);
    virtual void removeItem(GroupedProxyItem *item);
    virtual void removeUnusedGroups(GroupedProxyItem *parent = NULL);
    virtual void reloadSourceModel();
    virtual void modelResetHandler();
    virtual void dataChangedHandler(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles = QVector<int>());
    virtual void rowsInsertedHandler(const QModelIndex &parent, int first, int last);
    virtual void rowsRemovedHandler(const QModelIndex &parent, int first, int last);
    virtual void rowsMovedHandler(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row);

  protected:
    GroupedProxyItem * m_root;
    GroupedProxyItem * m_defaultParent;
    QHash<int, GroupedProxyItem *> m_sourceMap;
    QVector<int> m_groups;
    int m_groupMatchRole;
    int m_groupColumnProxySrc;
    bool m_groupColumnVisible;
    bool m_groupColumnIsProxy;
    bool m_groupRowSelectable;
    int m_defaultParentGroup;
    bool m_rowsAreMoving;

  private:
    bool setReloadSuspended(bool enable) { bool prev = m_reloadSuspended; m_reloadSuspended = enable; return prev; }
    bool reloadSuspended() const { return m_reloadSuspended; }

    bool m_reloadSuspended;


  protected:
    class GroupedProxyItem
    {
      public:
        explicit GroupedProxyItem(const QModelIndex &srcIndex, const bool isSrcItem = false, GroupedProxyItem *parent = NULL);
        explicit GroupedProxyItem(GroupedProxyItem *parent = NULL);
        virtual ~GroupedProxyItem();

        int row() const;
        QVariant data(int role = Qt::EditRole)    const { return m_itemData.value(role, QVariant()); }
        QMap<int, QVariant> itemData()            const { return m_itemData; }
        int rowCount()                            const { return m_childItems.size(); }
        QVector<GroupedProxyItem *> children()    const { return m_childItems; }
        GroupedProxyItem * child(const int row)   const { return m_childItems.value(row, NULL); }
        int childRow(GroupedProxyItem * child)    const { return m_childItems.indexOf(child); }
        GroupedProxyItem * parent()               const { return m_parentItem; }

        QModelIndex sourceIndex() const { return m_sourceIndex; }
        bool isSourceItem()       const { return m_isSourceItem; }
        bool isGroupItem()        const { return !isSourceItem(); }

        void clear();
        GroupedProxyItem * addChild(const QModelIndex &srcIndex, const bool isSrcItem = true);
        void removeChild(GroupedProxyItem * item);
        void removeChild(const int row) { removeChild(child(row)); }
        bool setData(const QVariant &data, int role = Qt::EditRole);
        bool setItemData(const QMap<int, QVariant> &roles);

      protected:
        GroupedProxyItem * m_parentItem;
        QVector<GroupedProxyItem *> m_childItems;
        QMap<int, QVariant> m_itemData;
        QPersistentModelIndex m_sourceIndex;
        bool m_isSourceItem;

        friend class GroupedItemsProxyModel;
    };  // GroupedProxyItem
    \
};  // GroupedItemsProxyModel

#endif // GROUPEDITEMSPROXYMODEL_H