src/models/FilterProxyModel.cpp - dev-ver1 - friendlyperch/QGrid

src/models/FilterProxyModel.cpp
289 строк7 KB
friendlyperch
add review notes, fix case-sensitive includes and Qt6.10 filter API
18 апр 2026, 18:13
18 апр 2026, 18:131b6df60
#include "FilterProxyModel.h"

#include "QGrid/Filter.h"
#include "QGrid/Group.h"
#include "QGrid/GridCommon.h"
#include "QGrid/GridColumn.h"
#include "UniversalTableModel.h"

#include <QDebug>

FilterProxyModel::FilterProxyModel(QObject *parent) : QSortFilterProxyModel(parent)
{
    mFilters = new Group(this);
    setDynamicSortFilter(true);
}

void FilterProxyModel::setFilters(const Group &filters)
{
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    beginFilterChange();
#endif
    mFilters->clear();
    mFilters->setOperation(filters.getOperation());
    
    for (Filter *filter : filters.getFilters())
    {
        if (filter)
        {
            mFilters->addFilter(*filter);
        }
    }
    
    for (Group *subGroup : filters.getGroups())
    {
        if (subGroup)
        {
            mFilters->addGroup(*subGroup);
        }
    }
    
#if QT_VERSION >= QT_VERSION_CHECK(6, 10, 0)
    endFilterChange();
#elif QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    invalidateFilter();
#endif
}

void FilterProxyModel::clearFilters()
{
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    beginFilterChange();
#endif

    mFilters->clear();
    
#if QT_VERSION >= QT_VERSION_CHECK(6, 10, 0)
    endFilterChange();
#elif QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    invalidateFilter();
#endif
}

bool FilterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
{
    Q_UNUSED(sourceParent)

    if (!mFilters || mFilters->isEmpty())
    {
        return true;
    }

    UniversalTableModel *sourceModel = getSourceModel();
    if (!sourceModel)
    {
        return true;
    }

    QModelIndex sourceIndex = sourceModel->index(sourceRow, 0);
    if (!sourceIndex.isValid())
    {
        return false;
    }

    return matchesFilter(sourceIndex, *mFilters);
}

bool FilterProxyModel::matchesFilter(const QModelIndex &sourceIndex, const Group &group) const
{
    if (group.isEmpty())
    {
        return true;
    }

    UniversalTableModel *sourceModel = getSourceModel();
    if (!sourceModel)
    {
        return false;
    }

    QList<Filter *> filters = group.getFilters();
    QList<Group *> groups = group.getGroups();

    if (filters.isEmpty() && groups.isEmpty())
    {
        return true;
    }

    bool result = false;
    bool firstItem = true;

    GroupOperation operation = group.getOperation();

    for (Filter *filter : filters)
    {
        if (!filter)
            continue;

        QString fieldName = filter->getFieldName();
        QVariant fieldValue = getFieldValue(sourceIndex, fieldName);
        Operation filterOperation = filter->getOperation();
        QList<QVariant> filterValues = filter->getValues();

        bool filterMatches = false;

        if (filterValues.isEmpty())
        {
            filterMatches = true;
        }
        else
        {
            for (const QVariant &filterValue : filterValues)
            {
                if (matchesOperation(fieldValue, fieldName, static_cast<int>(filterOperation), filterValue))
                {
                    filterMatches = true;
                    break;
                }
            }
        }

        if (firstItem)
        {
            result = filterMatches;
            firstItem = false;
        }
        else
        {
            if (operation == GroupOperation::And)
            {
                result = result && filterMatches;
            }
            else
            {
                result = result || filterMatches;
            }
        }
    }

    for (Group *subGroup : groups)
    {
        if (!subGroup)
            continue;

        bool groupMatches = matchesFilter(sourceIndex, *subGroup);

        if (firstItem)
        {
            result = groupMatches;
            firstItem = false;
        }
        else
        {
            if (operation == GroupOperation::And)
            {
                result = result && groupMatches;
            }
            else
            {
                result = result || groupMatches;
            }
        }
    }

    return result;
}

bool FilterProxyModel::matchesOperation(const QVariant &value, const QString &fieldName, int operation,
                                        const QVariant &filterValue) const
{
    Q_UNUSED(fieldName)

    Operation op = static_cast<Operation>(operation);

    switch (op)
    {
    case Operation::Like:
    {
        QString valueStr = value.toString();
        QString filterStr = filterValue.toString();
        return valueStr.contains(filterStr, Qt::CaseInsensitive);
    }
    case Operation::Equal:
    {
        return value == filterValue;
    }
    case Operation::NotEqual:
    {
        return value != filterValue;
    }
    case Operation::None:
    default:
        return true;
    }
}

UniversalTableModel *FilterProxyModel::getSourceModel() const
{
    return qobject_cast<UniversalTableModel *>(sourceModel());
}

QVariant FilterProxyModel::getFieldValue(const QModelIndex &sourceIndex, const QString &fieldName) const
{
    UniversalTableModel *sourceModel = getSourceModel();
    if (!sourceModel)
    {
        return QVariant();
    }

    QObject *obj = sourceModel->getObjectByIndex(sourceIndex.row());
    if (obj)
    {
        QVariant value = obj->property(fieldName.toStdString().data());
        if (value.isValid())
        {
            QVector<GridColumn *> columns = sourceModel->getColumns();
            for (GridColumn *column : columns)
            {
                if (column && column->getFieldName() == fieldName)
                {
                    if (column->getValueFunc() != nullptr)
                    {
                        return column->getValueFunc()(value);
                    }
                    break;
                }
            }
            return value;
        }
    }

    return QVariant();
}

bool FilterProxyModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
{
    UniversalTableModel *sourceModel = getSourceModel();
    if (!sourceModel)
    {
        return QSortFilterProxyModel::lessThan(left, right);
    }

    int column = left.column();
    GridColumn *gridColumn = sourceModel->getColumn(column);
    
    if (!gridColumn || !gridColumn->getSortable())
    {
        return false;
    }

    return QSortFilterProxyModel::lessThan(left, right);
}

void FilterProxyModel::sort(int column, Qt::SortOrder order)
{
    UniversalTableModel *sourceModel = getSourceModel();
    if (!sourceModel)
    {
        QSortFilterProxyModel::sort(column, order);
        return;
    }

    GridColumn *gridColumn = sourceModel->getColumn(column);
    if (!gridColumn || !gridColumn->getSortable())
    {
        return;
    }

    QSortFilterProxyModel::sort(column, order);
}