Piles

Go to the documentation of this file.

#ifndef GUARD_GROUPMODEL_H_INCLUDE
#define GUARD_GROUPMODEL_H_INCLUDE

#include <grouplistwidget/grouplistwidget-config.h>
#include <QVariant>
#include <QList>
#include <QObject>
#include <QVector>

QT_BEGIN_NAMESPACE
class QAbstractItemModel;
QT_END_NAMESPACE

class GroupSubModel;

class ModelId : private QPair<int,Qt::ItemDataRole> {
public:
    ModelId () : QPair<int,Qt::ItemDataRole>(-1, Qt::UserRole) {}
    ModelId (int column, Qt::ItemDataRole role) : QPair<int,Qt::ItemDataRole>(column, role) {}
    int column () const { return first; }
    void setColumn (int value) { first = value; }
    Qt::ItemDataRole role () const { return second; }
    void setRole (Qt::ItemDataRole value) { second = value; }
};

class GROUPLISTWIDGET_EXPORT GroupModel : public QObject {
    Q_OBJECT
public:


    enum { BaseColRole = Qt::UserRole + 1000 };

    enum ComparisionReslt {
        Equal = 0,
        Smaller = -1,
        Larger = 1
    };

    typedef ComparisionReslt (*Compare) (
            GroupModel * model,
            int column,
            const QVariant & v1,
            const QVariant & v2);

    /*  &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */

    GroupModel (
            QAbstractItemModel *model = NULL,
            QObject * parent = NULL);

    virtual ~GroupModel();

    virtual void
    setBaseModel (
            QAbstractItemModel * model,
            int grouping_col = -1,
            int sorting_col = -1,
            Qt::SortOrder group_dir = Qt::AscendingOrder,
            Qt::SortOrder sort_dir = Qt::AscendingOrder);

    virtual QAbstractItemModel *
    baseModel () const;

    QAbstractItemModel *
    takeBaseModel ();

    virtual void
    setPixmapColumn (
            int column);

    virtual int
    pixmapColumn () const;

    virtual void
    setPixmapRole (
            Qt::ItemDataRole role);

    virtual Qt::ItemDataRole
    pixmapRole () const;

    virtual QPixmap
    pixmap (
            int row) const;


    virtual void
    setUserData (
            const QVariant & value) {
        user_data_ = value;
    }

    virtual const QVariant &
    userData () const {
        return user_data_;
    }


signals:

    void
    modelAboutToBeReset ();

    void
    modelReset ();

public:

    static ComparisionReslt
    defaultCompare (
            GroupModel * model,
            int column,
            const QVariant & v1,
            const QVariant & v2);

protected:

    virtual QStringList
    columnLabels (
            const QList<int> & scols,
            int * idx_crt,
            int highlite) const;

    void
    resetAllSubGroups ();


    /*  &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */

public:


    const ModelId &
    label () const {
        Q_ASSERT(additional_labels_.length () > 0);
        return additional_labels_.at (0);
    }

    int
    labelCount () const {
        return additional_labels_.count ();
    }

    ModelId
    label (int idx) const {
        if ((idx < 0) || (idx > additional_labels_.length ())) {
            return ModelId ();
        } else {
            return additional_labels_.at (idx);
        }
    }

    void
    addLabel (
            const ModelId & value) {
        additional_labels_.append (value);
        resetAllSubGroups ();
    }

    void
    addLabel (
            int column, Qt::ItemDataRole role = Qt::DisplayRole) {
        addLabel (ModelId (column, role));
    }

    void
    setLabel (
            const ModelId & value) {
        Q_ASSERT(additional_labels_.length () > 0);
        additional_labels_[0] = value;
        resetAllSubGroups ();
    }

    void
    setLabel (
            const ModelId & value,
            int idx) {
        if ((idx < 0) || (idx > additional_labels_.length ())) {
            return;
        } else {
            additional_labels_[idx] = value;
            resetAllSubGroups ();
        }
    }

    void
    setLabel (
            int column,
            Qt::ItemDataRole role = Qt::DisplayRole,
            int idx = 0) {
        setLabel (ModelId (column, role), idx);
    }

    /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */


    /*  &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */

public:

    virtual int
    groupingColumn () const {
        return group_.column ();
    }

    virtual int
    isGrouping () const {
        return group_.column() != -1;
    }

    virtual void
    setGroupingRole (
            Qt::ItemDataRole role) {
        group_.setRole (role);
    }

    virtual Qt::ItemDataRole
    groupingRole () const {
        return group_.role ();
    }

    virtual void
    setGroupLabelRole (
            Qt::ItemDataRole role) {
        group_label_role_ = role;
    }

    virtual Qt::ItemDataRole
    groupLabelRole () const {
        return group_label_role_;
    }

    virtual Qt::SortOrder
    groupingDirection () const {
        return group_dir_;
    }

    virtual void
    setGroupingFunc (
            Compare value) {
        if (value == NULL)
            value = defaultCompare;
        group_func_ = value;
    }

    virtual Compare
    groupingFunc () const {
        return group_func_;
    }

    virtual GroupSubModel *
    group (
            int idx) const;

    virtual int
    groupCount () const {
        return groups_.count();
    }

    virtual QList<int>
    groupingColumns () const;

    virtual QStringList
    groupingColumnLabels (
            int * idx_crt) const;


public slots:

    virtual bool
    setGroupingColumn (
            int column);

    virtual bool
    setGroupingColumnByProperty () {
        return setGroupingColumn (sender()->property("columnIndex").toInt ());
    }

    void
    removeGrouping () {
        setGroupingColumn (-1);
    }

    virtual void
    setGroupingDirection (
            Qt::SortOrder value) {
        group_dir_ = value;
        if (!supress_signals_)
            emit groupingChanged (group_.column(), group_dir_);
    }

    void
    setGroupingAscending () {
        setGroupingDirection (Qt::AscendingOrder);
    }

    void
    setGroupingDescending () {
        setGroupingDirection (Qt::DescendingOrder);
    }

protected:

    virtual void
    buildAllGroups();

    virtual void
    buildNoGroupingGroup();

    virtual void
    clearAllGroups ();

signals:

    void
    groupingChanged (
            int column,
            Qt::SortOrder);

    /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */



    /*  &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */

public:

    virtual int
    sortingColumn () const {
        return sort_.column();
    }

    virtual int
    isSorting () const {
        return sort_.column() != -1;
    }

    virtual void
    setSortingRole (
            Qt::ItemDataRole role) {
        sort_.setRole (role);
        if (!supress_signals_)
            emit sortingChanged (sort_.column(), sort_dir_);
    }

    virtual Qt::ItemDataRole
    sortingRole () const {
        return sort_.role ();
    }


    virtual Qt::SortOrder
    sortingDirection () const {
        return sort_dir_;
    }

    virtual void
    setSortingFunc (
            Compare value) {
        if (value == NULL)
            value = defaultCompare;
        sort_func_ = value;
    }

    virtual Compare
    sortingFunc () const {
        return sort_func_;
    }

    virtual QList<int>
    sortingColumns () const;

    virtual QStringList
    sortingColumnLabels (
            int * idx_crt) const;

public slots:

    virtual bool
    setSortingColumn (
            int column);

    virtual bool
    setSortingColumnByProperty () {
        return setSortingColumn (sender()->property ("columnIndex").toInt ());
    }

    void
    removeSorting () {
        setSortingColumn (-1);
    }

    virtual void
    setSortingDirection (
            Qt::SortOrder value);

    void
    setSortingAscending () {
        setSortingDirection (Qt::AscendingOrder);
    }

    void
    setSortingDescending () {
        setSortingDirection (Qt::DescendingOrder);
    }

protected:

    virtual void
    performSorting ();

    virtual void
    performUnsorting ();

signals:

    void
    sortingChanged (
            int column,
            Qt::SortOrder);

    /*  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  */


private slots:

    void
    baseModelDataChange (
            const QModelIndex &topLeft,
            const QModelIndex &bottomRight,
            const QVector<int> &roles = QVector<int>());

private:

    void
    installBaseModel (
            QAbstractItemModel * value);

    void
    uninstallBaseModel (
            bool do_delete = true);

    GroupSubModel *
    groupFromBaseRow (
            int base_row,
            int * index_in_group);


    QAbstractItemModel * m_base_; 
    ModelId pixmap_; 
    ModelId group_; 
    Qt::ItemDataRole group_label_role_; 
    Qt::SortOrder group_dir_; 
    Compare group_func_; 
    ModelId sort_; 
    Qt::SortOrder sort_dir_; 
    Compare sort_func_; 
    QVariant user_data_; 
    QList<GroupSubModel*> groups_; 
    bool supress_signals_; 
    QList<ModelId> additional_labels_; 
}; // class GroupModel

#endif // GUARD_GROUPMODEL_H_INCLUDE