simulateddatamodel.cpp

Enable keyboard shortcuts

++ // Copyright (C) 2026 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause

++

++ #include "simulateddatamodel.h"

++

++ SimulatedDataModel::SimulatedDataModel(QObject *parent)

++     : QAbstractListModel(parent)

++     , m_rowMin(0.0)

++     , m_rowMax(1.0)

++     , m_columnMin(0.0)

++     , m_columnMax(1.0)

++ { }

++

++ int SimulatedDataModel::numberOfRows() const

++ {

++     return m_numberOfRows;

++ }

++

++ void SimulatedDataModel::setNumberOfRows(int numberOfRows)

++ {

++     if (m_numberOfRows == numberOfRows)

++         return;

++

++     m_numberOfRows = numberOfRows;

++ }

++

++ int SimulatedDataModel::numberOfColumns() const

++ {

++     return m_numberOfColumns;

++ }

++

++ void SimulatedDataModel::setNumberOfColumns(int numberOfColumns)

++ {

++     if (m_numberOfColumns == numberOfColumns)

++         return;

++

++     m_numberOfColumns = numberOfColumns;

++ }

++

++ void SimulatedDataModel::setRowRole(const QString &role)

++ {

++     if (m_rowRole == role)

++         return;

++

++     m_rowRole = role;

++     emit rowRoleChanged(role);

++ }

++

++ QString SimulatedDataModel::rowRole() const

++ {

++     return m_rowRole;

++ }

++

++ void SimulatedDataModel::setColumnRole(const QString &role)

++ {

++     if (m_columnRole == role)

++         return;

++

++     m_columnRole = role;

++     emit columnRoleChanged(role);

++ }

++

++ QString SimulatedDataModel::columnRole() const

++ {

++     return m_columnRole;

++ }

++

++ void SimulatedDataModel::setValueRole(const QString &role)

++ {

++     if (m_valueRole == role)

++         return;

++

++     m_valueRole = role;

++     emit valueRoleChanged(role);

++ }

++

++ QString SimulatedDataModel::valueRole() const

++ {

++     return m_valueRole;

++ }

++

++ int SimulatedDataModel::rowCount(const QModelIndex &parent) const

++ {

++     return m_data.size();

++ }

++

++ QVariant SimulatedDataModel::data(const QModelIndex &index, int role) const

++ {

++     if (!index.isValid())

++         return QVariant();

++

++     if (index.row() >= m_data.size())

++         return QVariant();

++

++     const ModelData &modelData = m_data.at(index.row());

++

++     switch (role) {

++         case RowRole:

++             return modelData.row;

++         case ColumnRole:

++             return modelData.column;

++         case ValueRole:

++             return modelData.value;

++         default:

++             return QVariant();

++     }

++ }

++

++ void SimulatedDataModel::setRowMin(qreal min)

++ {

++     if (qFuzzyCompare(m_rowMin, min))

++         return;

++

++     m_rowMin = min;

++     emit rowMinChanged(min);

++ }

++

++ void SimulatedDataModel::setRowMax(qreal max)

++ {

++     if (qFuzzyCompare(m_rowMax, max))

++         return;

++

++     m_rowMax = max;

++     emit rowMaxChanged(max);

++ }

++

++ void SimulatedDataModel::setColumnMin(qreal min)

++ {

++     if (qFuzzyCompare(m_columnMin, min))

++         return;

++

++     m_columnMin = min;

++     emit columnMinChanged(min);

++ }

++

++ void SimulatedDataModel::setColumnMax(qreal max)

++ {

++     if (qFuzzyCompare(m_columnMax, max))

++         return;

++

++     m_columnMax = max;

++     emit columnMaxChanged(max);

++ }

++

++ void SimulatedDataModel::setRowReversed(bool reversed)

++ {

++     if (m_rowReversed == reversed)

++         return;

++

++     m_rowReversed = reversed;

++     emit rowReversedChanged(reversed);

++ }

++

++ void SimulatedDataModel::setColumnReversed(bool reversed)

++ {

++     if (m_columnReversed == reversed)

++         return;

++

++     m_columnReversed = reversed;

++     emit columnReversedChanged(reversed);

++ }

++

++ QHash<int, QByteArray> SimulatedDataModel::roleNames() const

++ {

++     QHash<int, QByteArray> ret;

++     ret[RowRole] = m_rowRole.toLatin1();

++     ret[ColumnRole] = m_columnRole.toLatin1();

++     ret[ValueRole] = m_valueRole.toLatin1();

++     return ret;

++ }

++

++ void SimulatedDataModel::generateModelData(const QVariantList &data,

++                                            int numberOfColumns,

++                                            int numberOfRows,

++                                            int numberOfData)

++ {

++     Q_UNUSED(numberOfColumns)

++

++     beginResetModel();

++

++     m_data.clear();

++     m_data.reserve(data.size());

++

++     const int columnSize = data.size() / (numberOfRows * numberOfData);

++     const bool intRows = (numberOfRows == int(m_rowMax - m_rowMin));

++     const bool intColumns = (columnSize == int(m_columnMax - m_columnMin));

++     const float rowRange = m_rowMax - m_rowMin;

++     const float columnRange = m_columnMax - m_columnMin;

++     const float rowScale = rowRange / float(numberOfRows);

++     const float columnScale = columnRange / float(columnSize);

++

++     for (int i = 0; i < columnSize; ++i) {

++         const int columnIdx = m_columnReversed ? (columnSize - 1 - i) : i;

++         const float columnValue = intColumns ? columnIdx + m_columnMin

++                                              : columnIdx * columnScale + m_columnMin;

++         const int baseIndex = i * numberOfRows;

++

++         for (int j = 0; j < numberOfRows; ++j) {

++             const int rowIdx = m_rowReversed ? (numberOfRows - 1 - j) : j;

++             ModelData modelData;

++             modelData.row = intRows ? rowIdx + m_rowMin : rowIdx * rowScale + m_rowMin;

++             modelData.column = columnValue;

++             modelData.value = data.at(baseIndex + j);

++

++             m_data.append(modelData);

++         }

++     }

++

++     endResetModel();

++ }