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

src/GridView.cpp
390 строк10 KB
FriendlyPerch
prepare for deploy
17 янв 2026, 15:26
17 янв 2026, 15:26d7fce50
#include "QGrid/GridView.h"
#include "ColumnsSerializer.h"
#include "FilterHeaderView.h"
#include "FilterableTableView.h"
#include "models/UniversalTableModel.h"

#include "ui_GridView.h"

#include <QDebug>
#include <QHeaderView>
#include <QStringList>

GridView::GridView(QWidget *parent) : QFrame(parent), mUi(new Ui::GridView)
{
    qRegisterMetaType<GridColumn>("GridColumn");
    qRegisterMetaType<ColumnsVector>("ColumnsVector");

    mUi->setupUi(this);

    mUi->staticFilters->hide();
    toolbar = new QToolBar();

    QBoxLayout *toolboxLayout = new QBoxLayout(QBoxLayout::LeftToRight);
    toolboxLayout->addWidget(toolbar);
    mUi->toolbar->setLayout(toolboxLayout);

    mUi->verticalScrollBar->setRange(mUi->filterableTableView->verticalScrollBar()->minimum(),
                                     mUi->filterableTableView->verticalScrollBar()->maximum());
    mUi->verticalScrollBar->setValue(mUi->filterableTableView->verticalScrollBar()->value());

    connect(mUi->staticFilters, qOverload<Group>(&StaticFilter::filtersChanged), this,
            &GridView::onChangedStaticFilters);
    connect(mUi->filterableTableView->getFilterHeader(), qOverload<const Group &>(&FilterHeaderView::filtersChanged),
            this, &GridView::onChangedSearchBarFilters);

    tableModel = mUi->filterableTableView->getTableModel();
    connect(mUi->filterableTableView->verticalScrollBar(), &QScrollBar::rangeChanged, this,
            &GridView::onTableDataVerticalScrollRangeChanged);
    connect(mUi->filterableTableView->selectionModel(), &QItemSelectionModel::currentRowChanged, this,
            &GridView::onTableDataSelectedRowChanged);
    connect(mUi->verticalScrollBar, &QScrollBar::valueChanged, mUi->filterableTableView->verticalScrollBar(),
            &QScrollBar::setValue);
    connect(mUi->filterableTableView->verticalScrollBar(), &QScrollBar::valueChanged, mUi->verticalScrollBar,
            &QScrollBar::setValue);

    recreateToolBox();

    mUi->filterableTableView->setSelectionMode(QAbstractItemView::SingleSelection);
    mUi->filterableTableView->setSelectionBehavior(QAbstractItemView::SelectRows);
    mUi->filterableTableView->setSearchBarShow(false);

    mUi->globalSearchWidget->hide();
    connect(mUi->globalSearchButton, &QPushButton::clicked, this, &GridView::onGlobalSearchButtonClicked);
    connect(mUi->globalSearchLineEdit, &QLineEdit::returnPressed, this, &GridView::onGlobalSearchButtonClicked);
    connect(mUi->globalSearchLineEdit, &QLineEdit::textChanged, this, &GridView::onGlobalSearchTextChanged);
}

GridView::~GridView()
{
    delete mUi;
}

bool GridView::getHeaderVisible() const
{
    return mUi->headerText->isVisible();
}

void GridView::setHeaderVisible(bool value)
{
    mUi->headerText->setVisible(value);
}

QString GridView::getHeaderText() const
{
    return mUi->headerText->text();
}

void GridView::setHeaderText(const QString &value)
{
    if (mUi->headerText->text() != value)
    {
        mUi->headerText->setText(value);
    }
}

ColumnsVector GridView::getColumns() const
{
    return mColumns;
}

void GridView::setColumns(const ColumnsVector &value)
{
    mColumns = value;
    mUi->filterableTableView->setColumns(mColumns);
    mUi->staticFilters->setFilters(mColumns);
    mUi->staticFilters->setVisible(mUi->staticFilters->getHasItem());
    tableModel->setFilters(mUi->staticFilters->getFilters());

    for (GridColumn *c : mColumns)
    {
        if (c->getIsId())
            idColumn = c;
        if (c->getIsParentId())
            parentIdColumn = c;
    }
}

QString GridView::getColumnsData() const
{
    return ColumnsSerializer::serialize(mColumns);
}

void GridView::setColumnsData(const QString &value)
{
    if (mUpdatingColumnsData)
    {
        return;
    }

    mUpdatingColumnsData = true;

    ColumnsVector newColumns = ColumnsSerializer::deserialize(value, this);
    setColumns(newColumns);

    mUpdatingColumnsData = false;
}

Mode GridView::getMode() const
{
    return mode;
}

void GridView::setMode(const Mode &value)
{
    if (mode != value)
    {
        mode = value;
        mUi->filterableTableView->setMode(mode);
        recreateToolBox();
        emit modeChanged(mode);
    }
}

void GridView::setDatasource(ActiveListBase *value)
{
    mUi->filterableTableView->setDatasource(value);
    emit currentRowChanged(nullptr);
}

ActiveListBase *GridView::getDatasource() const
{
    return mUi->filterableTableView->getDatasource();
}

void GridView::clearDatasource()
{
    setDatasource(nullptr);
}

void GridView::reloadDatasource()
{
    mUi->filterableTableView->resizeColumnsToContents();
}

void GridView::deleteCurrentRow()
{
    auto ds = getDatasource();
    if(ds)
    {
        auto r = mUi->filterableTableView->currentIndex().row();
        ds->removeRequest(r);
    }
}

void GridView::insertRow()
{
    auto ds = getDatasource();
    if(ds)
    {
        ds->createRequest();
    }
}

void GridView::onChangedStaticFilters(Group filters)
{
    staticFilters = filters;
    emit filtersChanged(mergeFilters());
}

void GridView::onChangedSearchBarFilters(Group filters)
{
    searchBarFilters = filters;
    emit filtersChanged(mergeFilters());
}

void GridView::onParentCurrentRowChanged(QObject *object)
{
    parentFilter.clear();

    QString parentIdFieldName = parentGrid->getIdColumn()->getFieldName();
    QVariant value;
    if (object)
        value = object->property(parentIdFieldName.toStdString().data());
    parentFilter.addFilterEqual(parentIdColumn->getFieldName(), value);

    emit filtersChanged(mergeFilters());
}

void GridView::onRefreshButtonClick()
{
    emit refresh(mergeFilters());
}

void GridView::onTableDataSelectedRowChanged(const QModelIndex &current, const QModelIndex &previous)
{
    Q_UNUSED(previous)

    emit currentRowChanged(mUi->filterableTableView->getSelectedObject());
}

void GridView::onTableDataVerticalScrollRangeChanged(int min, int max)
{
    mUi->verticalScrollBar->setRange(min, max);
}

void GridView::recreateToolBox()
{
    toolbar->clear();
    createToolbox();
}

void GridView::createToolbox()
{
    QIcon refreshIcon = style()->standardIcon(QStyle::SP_BrowserReload);
    QAction *refresh = new QAction(refreshIcon, tr("Refresh"), this);
    connect(refresh, SIGNAL(triggered(bool)), this, SLOT(onRefreshButtonClick()));
    toolbar->addAction(refresh);
    toolbar->addSeparator();
    if (mode == Mode::ReadWrite)
    {
        QIcon insertIcon = style()->standardIcon(QStyle::SP_FileIcon);
        QAction *insert = new QAction(insertIcon, tr("Add"), this);
        toolbar->addAction(insert);
        connect(insert, SIGNAL(triggered(bool)), this, SLOT(insertRow()));

        QIcon delIcon = style()->standardIcon(QStyle::SP_BrowserStop);
        QAction *del = new QAction(delIcon, tr("Remove"), this);
        toolbar->addAction(del);
        connect(del, SIGNAL(triggered(bool)), this, SLOT(deleteCurrentRow()));
    }
}

Group GridView::mergeFilters()
{
    Group filters;
    filters.setOperation(GroupOperation::And);

    if (!staticFilters.isEmpty())
        filters.addGroup(staticFilters);
    if (!searchBarFilters.isEmpty())
        filters.addGroup(searchBarFilters);
    if (!parentFilter.isEmpty())
        filters.addGroup(parentFilter);

    return filters;
}

bool GridView::getSearchBarShow() const
{
    return mUi->filterableTableView->getSearchBarShow();
}

void GridView::setSearchBarShow(bool value)
{
    mUi->filterableTableView->setSearchBarShow(value);
}

void GridView::showEvent(QShowEvent *event)
{
    QFrame::showEvent(event);
    mUi->filterableTableView->getFilterHeader()->updateFilterWidgetsGeometry();
}

bool GridView::getToolboxVisible() const
{
    return mUi->toolbar->isVisible();
}

void GridView::setToolboxVisible(bool value)
{
    mUi->toolbar->setVisible(value);
}

GridView *GridView::getParentGrid() const
{
    return parentGrid;
}

void GridView::setParentGrid(GridView *value)
{
    if (parentGrid != value)
    {
        parentGrid = value;
        connect(parentGrid, SIGNAL(currentRowChanged(QObject *)), SLOT(onParentCurrentRowChanged(QObject *)));
    }
}

QObject *GridView::getSelectedObject()
{
    return mUi->filterableTableView->getSelectedObject();
}

void GridView::setCheckableSelectionEnabled(bool enabled)
{
    mUi->filterableTableView->setCheckableSelectionEnabled(enabled);
}

bool GridView::getCheckableSelectionEnabled() const
{
    return mUi->filterableTableView->getCheckableSelectionEnabled();
}

GridColumn *GridView::getParentIdColumn() const
{
    return parentIdColumn;
}

GridColumn *GridView::getIdColumn() const
{
    return idColumn;
}

bool GridView::getGlobalSearchEnabled() const
{
    return mGlobalSearchEnabled;
}

void GridView::setGlobalSearchEnabled(bool value)
{
    if (mGlobalSearchEnabled != value)
    {
        mGlobalSearchEnabled = value;
        mUi->globalSearchWidget->setVisible(value);
        
        if (!value)
        {
            mUi->globalSearchLineEdit->clear();
            globalSearchFilter.clear();
            mUi->filterableTableView->setGlobalSearchFilter(globalSearchFilter);
        }
    }
}

void GridView::onGlobalSearchButtonClicked()
{
    QString searchText = mUi->globalSearchLineEdit->text().trimmed();
    performGlobalSearch(searchText);
}

void GridView::onGlobalSearchTextChanged(const QString &text)
{
    if (text.isEmpty())
    {
        globalSearchFilter.clear();
        mUi->filterableTableView->setGlobalSearchFilter(globalSearchFilter);
    }
}

void GridView::performGlobalSearch(const QString &searchText)
{
    globalSearchFilter.clear();
    
    if (searchText.isEmpty())
    {
        mUi->filterableTableView->setGlobalSearchFilter(globalSearchFilter);
        return;
    }
    
    globalSearchFilter.setOperation(GroupOperation::Or);
    
    for (GridColumn *column : mColumns)
    {
        if (column && column->getVisible() && !column->getFieldName().isEmpty())
        {
            globalSearchFilter.addFilter(column->getFieldName(), Operation::Like, searchText);
        }
    }
    
    mUi->filterableTableView->setGlobalSearchFilter(globalSearchFilter);
}