So im trying to figure out how you would go about making it where you can click on a checkbox inside a QListView and drag the mouse (while still clicked) over multiple checkboxes and it check them as well. Because right now I have to click all the checkboxes I want checked, where I would prefer if I need several in a row checked, I can just click on and drag to the last one I need checked.

Im not refering to a select all method either, I just need say out of 100 checkboxes there may be 25 in a row I need checked, and dont feel like having to check all them one at a time.

CodePudding user response：

You can use a custom delegate to watch for mouse clicks/moves and act on your model data.

A basic window with a list view and a series of checkboxes:
MainWindow.cpp

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow),
      m_model(new QStandardItemModel(9, 2))
{
    ui->setupUi(this);

    for (int row = 0; row < m_model->rowCount();   row) {
        QStandardItem *Item = new QStandardItem();
        Item->setCheckable( true );
        Item->setCheckState( Qt::Checked );
        m_model->setItem(row, Item);
    }

    ui->listView->setItemDelegateForColumn(0, new CustomDelegate(this));
    ui->listView->setModel(m_model);

}

A custom delegate with a paint event (replace this with however you are currently drawing your check box) and editorEvent.
In the`editorEvent`, on `MouseButtonPress` we check/uncheck boxes as appropriate and then remember if we were checking, or unchecking for reference in the `MouseMove`.
Then in `MouseMove` we check/uncheck boxes as we pass over them.

CustomDeletage.h

#ifndef CUSTOMDELEGATE_H
#define CUSTOMDELEGATE_H

#include <QApplication>
#include <QEvent>
#include <QMouseEvent>
#include <QPainter>
#include <QStyledItemDelegate>

class CustomDelegate : public QStyledItemDelegate
{
    Q_OBJECT
public:
    CustomDelegate(QObject *parent );

    void paint( QPainter * painter, const QStyleOptionViewItem & option, const QModelIndex & index ) const
    {
        Q_ASSERT(index.isValid());

        // Get value from model.
        bool  state = index.data( Qt::DisplayRole ).toInt();
        QStyleOptionButton optBtn;

        optBtn.state = QStyle::State_Enabled; // CheckBox enabled
        if ( option.state & QStyle::State_MouseOver )
            optBtn.state |= QStyle::State_MouseOver; // Mouse over cell

        // If value is true - checked box, otherwise - unchecked box.
        if(state) {
            optBtn.state |= QStyle::State_On;
        } else {
            optBtn.state |= QStyle::State_Off;
        }

        // Check box rect, centered.
        optBtn.rect = QApplication::style()->subElementRect( QStyle::SE_CheckBoxIndicator, &optBtn, Q_NULLPTR );
        const int x = option.rect.center().x() - optBtn.rect.width() / 2;
        const int y = option.rect.center().y() - optBtn.rect.height() / 2;
        optBtn.rect.moveTo( x, y );

        // Draw the background color.
        if (option.state & QStyle::State_Selected && option.state & QStyle::State_Active)
            painter->fillRect(option.rect, option.palette.highlight());
        else if (option.state & QStyle::State_Selected)
            painter->fillRect(option.rect, option.palette.background());

        // Draw the check box.
        QApplication::style()->drawControl( QStyle::CE_CheckBox, &optBtn, painter );
    }


    bool editorEvent( QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index )
    {
        Q_UNUSED(option)
        switch ( event->type() )
        {
        case QEvent::MouseButtonPress:
        {
            // Do nothing if edit model is not editable.
            Qt::ItemFlags flags = model->flags(index);
            if(! flags.testFlag(Qt::ItemIsEditable) ) break;

            // Only accept left clicks.
            QMouseEvent *e = static_cast< QMouseEvent * >( event );
            if ( e->button() != Qt::LeftButton ) break;

            // Invert the current value.
            bool currentValue = model->data(index, Qt::DisplayRole).toBool();
            model->setData(index, !currentValue, Qt::EditRole);

            // Set the process as either checking, or unchecking.
            currentValue ? m_checkingOrUnchecking = 2 : m_checkingOrUnchecking = 1;
            break;
        }

        case QEvent::MouseMove:
        {
            // Do nothing if edit model is not editable.
            Qt::ItemFlags flags = model->flags(index);
            if(! flags.testFlag(Qt::ItemIsEditable) ) break;

            // If we are at the same index as the last time, break so we do not continuously invert the state of a single check box.
            if (index == m_lastPassedOverIndex) break;

            // If mouse is moved while clicked, set the box we pass over to the current checking or unchecking state.
            if(m_checkingOrUnchecking == 1) {
                model->setData(index, true, Qt::EditRole);
            } else if(m_checkingOrUnchecking == 2) {
                model->setData(index, false, Qt::EditRole);
            }

            // Make sure we are not double-inverting an index.
            m_lastPassedOverIndex = index;
            break;
        }

        case QEvent::MouseButtonRelease:
        {
            m_checkingOrUnchecking = 0;
            break;
        }

        default:
            break;
        }

        return true;
    }

private:
        QModelIndex m_lastPassedOverIndex; // The index last passed over, so while clicking over a check box, we do not continupusly invert its state.
        int m_checkingOrUnchecking = 0;  // Is the user currently checking, or unchecking boxes?  0 = do nothing, 1 = checking, 2 = unchecking.
};

#endif // CUSTOMDELEGATE_H