src/FilterableTableView.cpp - dev-ver1 - friendlyperch/QGrid

src/FilterableTableView.cpp
367 строк9 KB
FriendlyPerch
prepare for deploy
17 янв 2026, 15:26
17 янв 2026, 15:26d7fce50
#include "FilterableTableView.h"

#include "QGrid/GridColumn.h"
#include "QGrid/GridCommon.h"

#include "FilterHeaderView.h"
#include "QGrid/ActiveListBase.h"
#include "delegates/UniversalDelegate.h"
#include "models/UniversalTableModel.h"
#include "models/FilterProxyModel.h"
#include "QGrid/Group.h"

#include <QHeaderView>
#include <QMetaObject>
#include <QShowEvent>

FilterableTableView::FilterableTableView(QWidget *parent) : QTableView(parent)
{
    mTableModel = new UniversalTableModel(this);
    mProxyModel = new FilterProxyModel(this);
    mProxyModel->setSourceModel(mTableModel);
    setModel(mProxyModel);
    mGlobalSearchFilter = new Group(this);

    mFilterHeader = new FilterHeaderView(Qt::Horizontal, this);
    setHorizontalHeader(mFilterHeader);

    mUniversalDelegate = new UniversalDelegate(this);
    setItemDelegate(mUniversalDelegate);

    setSelectionMode(QAbstractItemView::SingleSelection);
    setSelectionBehavior(QAbstractItemView::SelectRows);
    setSortingEnabled(true);

    mCheckboxColumn = new GridColumn(this);
    mCheckboxColumn->setHeader("");
    mCheckboxColumn->setFieldName("");
    mCheckboxColumn->setCheckable(true);
    mCheckboxColumn->setVisible(false);
    mCheckboxColumn->setEditable(false);
    mCheckboxColumn->setShowInSearchBar(false);
    mCheckboxColumn->setSortable(false);

    connect(mFilterHeader, &FilterHeaderView::filtersChanged, this, &FilterableTableView::onFiltersChanged);
    connect(mFilterHeader, &FilterHeaderView::columnVisibilityChanged, this, &FilterableTableView::hideColumns);
    
    mTableModel->setSelectionChangedCallback([this](int row, bool selected)
    {
        if (selected)
        {
            mSelectedRows.insert(row);
        }
        else
        {
            mSelectedRows.remove(row);
        }
    });
}

FilterableTableView::~FilterableTableView()
{
}

void FilterableTableView::setColumns(const QVector<GridColumn *> &columns)
{
    mColumns = columns;
    
    QVector<GridColumn *> columnsWithCheckbox = columns;
    if (mCheckableSelectionEnabled && mCheckboxColumn)
    {
        columnsWithCheckbox.prepend(mCheckboxColumn);
    }
    
    mTableModel->setColumns(columnsWithCheckbox);
    mFilterHeader->setColumns(columns);
    mFilterHeader->setCheckboxColumnOffset(mCheckableSelectionEnabled ? 1 : 0);
    hideColumns();
}

QVector<GridColumn *> FilterableTableView::getColumns() const
{
    return mColumns;
}

void FilterableTableView::clearColumns()
{
    mColumns.clear();
}

void FilterableTableView::appendColumns(const QVector<GridColumn *> &newColumns)
{
    mColumns.append(newColumns);
}

void FilterableTableView::appendColumn(GridColumn *column)
{
    mColumns.append(column);
}

void FilterableTableView::removeColumn(GridColumn *column)
{
    mColumns.removeOne(column);
}

void FilterableTableView::removeAllColumns()
{
    mColumns.clear();
}

void FilterableTableView::setDatasource(ActiveListBase *datasource)
{
    ActiveListBase *oldDatasource = mTableModel->getDatasource();
    if (oldDatasource)
    {
        disconnect(oldDatasource, &ActiveListBase::created, this, nullptr);
    }
    
    mTableModel->setDatasource(datasource);
    
    if (datasource)
    {
        connect(datasource, &ActiveListBase::created, this, &FilterableTableView::onRowCreated, Qt::UniqueConnection);
    }
}

ActiveListBase *FilterableTableView::getDatasource() const
{
    return mTableModel->getDatasource();
}

QObject *FilterableTableView::getSelectedObject()
{
    QModelIndex proxyIndex = currentIndex();
    if (!proxyIndex.isValid())
        return nullptr;

    QModelIndex sourceIndex = mProxyModel->mapToSource(proxyIndex);
    if (!sourceIndex.isValid())
        return nullptr;

    return mTableModel->getObjectByIndex(sourceIndex.row());
}

QVector<QObject *> FilterableTableView::getSelectedObjects() const
{
    QVector<QObject *> result;
    
    if (!mTableModel->getDatasource())
        return result;
    
    QSet<int> sourceSelectedRows = mTableModel->getSelectedRows();
    for (int sourceRow : sourceSelectedRows)
    {
        QObject *obj = mTableModel->getObjectByIndex(sourceRow);
        if (obj)
        {
            result.append(obj);
        }
    }
    
    return result;
}

void FilterableTableView::setSearchBarShow(bool show)
{
    mFilterHeader->setSearchBarShow(show);
    updateGeometry();
}

bool FilterableTableView::getSearchBarShow() const
{
    return mFilterHeader->getSearchBarShow();
}

Mode FilterableTableView::getMode() const
{
    return mMode;
}

void FilterableTableView::setMode(const Mode &value)
{
    if (mMode != value)
    {
        mMode = value;
        mTableModel->setMode(mMode);
        emit modeChanged(mMode);
    }
}

void FilterableTableView::showEvent(QShowEvent *event)
{
    QTableView::showEvent(event);
    hideColumns();
}

void FilterableTableView::hideColumns()
{
    if (mCheckableSelectionEnabled)
    {
        setColumnHidden(0, false);
    }
    
    int columnOffset = mCheckableSelectionEnabled ? 1 : 0;
    int visualColumnIndex = columnOffset;
    
    for (auto column : mColumns)
    {
        if (column->getVisible())
        {
            int totalColumns = model() ? model()->columnCount() : 0;
            if (visualColumnIndex < totalColumns)
            {
                setColumnHidden(visualColumnIndex, false);
            }
            visualColumnIndex++;
        }
    }
    
    int totalColumns = model() ? model()->columnCount() : 0;
    for (int i = visualColumnIndex; i < totalColumns; ++i)
    {
        setColumnHidden(i, true);
    }
}

bool FilterableTableView::getCheckableSelectionEnabled() const
{
    return mCheckableSelectionEnabled;
}

void FilterableTableView::setCheckableSelectionEnabled(bool enabled)
{
    if (mCheckableSelectionEnabled != enabled)
    {
        mCheckableSelectionEnabled = enabled;
        mTableModel->setCheckableSelectionEnabled(enabled);
        
        if (!enabled)
        {
            mSelectedRows.clear();
            if (mCheckboxColumn)
            {
                mCheckboxColumn->setVisible(false);
            }
        }
        else
        {
            if (mCheckboxColumn)
            {
                mCheckboxColumn->setVisible(true);
            }
        }
        
        QVector<GridColumn *> columnsWithCheckbox = mColumns;
        if (mCheckableSelectionEnabled && mCheckboxColumn)
        {
            columnsWithCheckbox.prepend(mCheckboxColumn);
        }
        mTableModel->setColumns(columnsWithCheckbox);
        mFilterHeader->setCheckboxColumnOffset(mCheckableSelectionEnabled ? 1 : 0);
        
        updateCheckboxColumn();
        emit checkableSelectionEnabledChanged(enabled);
    }
}

void FilterableTableView::updateCheckboxColumn()
{
    if (mCheckableSelectionEnabled)
    {
        setColumnHidden(0, false);
        horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
    }
    hideColumns();
}

int FilterableTableView::getCheckboxColumnIndex() const
{
    return mCheckableSelectionEnabled ? 0 : -1;
}

void FilterableTableView::onCheckboxToggled(const QModelIndex &index, bool checked)
{
    Q_UNUSED(index);
    Q_UNUSED(checked);
}

void FilterableTableView::updateRowSelection(int sourceRow, bool selected)
{
    Q_UNUSED(sourceRow);
    Q_UNUSED(selected);
}

void FilterableTableView::updateAllSelections()
{
}

void FilterableTableView::onFiltersChanged(const Group &filters)
{
    Group mergedFilters;
    mergedFilters.setOperation(GroupOperation::And);
    
    if (!filters.isEmpty())
        mergedFilters.addGroup(filters);
    if (mGlobalSearchFilter && !mGlobalSearchFilter->isEmpty())
        mergedFilters.addGroup(*mGlobalSearchFilter);
    
    mProxyModel->setFilters(mergedFilters);
    emit filtersChanged(mergedFilters);
}

void FilterableTableView::setGlobalSearchFilter(const Group &filter)
{
    mGlobalSearchFilter->clear();
    mGlobalSearchFilter->setOperation(filter.getOperation());
    
    for (Filter *f : filter.getFilters())
    {
        if (f)
        {
            mGlobalSearchFilter->addFilter(*f);
        }
    }
    
    for (Group *g : filter.getGroups())
    {
        if (g)
        {
            mGlobalSearchFilter->addGroup(*g);
        }
    }
    
    Group headerFilters;
    if (mFilterHeader)
    {
        headerFilters = mFilterHeader->getFilters();
    }
    
    Group mergedFilters;
    mergedFilters.setOperation(GroupOperation::And);
    
    if (!headerFilters.isEmpty())
        mergedFilters.addGroup(headerFilters);
    if (!mGlobalSearchFilter->isEmpty())
        mergedFilters.addGroup(*mGlobalSearchFilter);
    
    mProxyModel->setFilters(mergedFilters);
    emit filtersChanged(mergedFilters);
}

void FilterableTableView::onRowCreated(size_t index)
{
    if (!mTableModel || !mProxyModel)
        return;
    
    QModelIndex sourceIndex = mTableModel->index(static_cast<int>(index), 0);
    if (!sourceIndex.isValid())
        return;
    
    QModelIndex proxyIndex = mProxyModel->mapFromSource(sourceIndex);
    if (!proxyIndex.isValid())
        return;
    
    setCurrentIndex(proxyIndex);
    scrollTo(proxyIndex, QAbstractItemView::EnsureVisible);
    selectRow(proxyIndex.row());
}