GostGenerator/model/componenttablemodel.cpp

#include "componenttablemodel.h"


ComponentTableModel::ComponentTableModel(QObject *parent)
    : QAbstractTableModel{parent}
{}

// Методы QAbstractTableModel
int ComponentTableModel::rowCount(const QModelIndex &parent) const
{
    if (parent.isValid())
        return 0;
    return m_components.size();
}

int ComponentTableModel::columnCount(const QModelIndex &parent) const
{
    if (parent.isValid())
        return 0;
    // ID + Designator + количество свойств
    return 2 + m_propertyNames.size();
}

QVariant ComponentTableModel::data(const QModelIndex &index, int role) const
{
    if (!index.isValid() || index.row() >= m_components.size())
        return QVariant();

    ComponentModel *component = m_components.at(index.row());
    if (!component)
        return QVariant();

    if (role == Qt::DisplayRole || role == Qt::EditRole) {
        int column = index.column();
        
        if (column == 0) {
            // ID
            return component->id();
        } else if (column == 1) {
            // Designator
            return component->designator();
        } else {
            // Свойства компонента
            int propertyIndex = column - 2;
            if (propertyIndex >= 0 && propertyIndex < m_propertyNames.size()) {
                QString propertyName = m_propertyNames.at(propertyIndex);
                QString propertyValue = component->properties().value(propertyName);
                

                
                return propertyValue;
            }
        }
    }

    return QVariant();
}

QVariant ComponentTableModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (role != Qt::DisplayRole)
        return QVariant();

    if (orientation == Qt::Horizontal) {
        if (section == 0) {
            return tr("ID");
        } else if (section == 1) {
            return tr("Обозначение");
        } else {
            int propertyIndex = section - 2;
            if (propertyIndex >= 0 && propertyIndex < m_propertyNames.size()) {
                return m_propertyNames.at(propertyIndex);
            }
        }
    } else {
        // Вертикальные заголовки - номера строк
        return section + 1;
    }

    return QVariant();
}

bool ComponentTableModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if (!index.isValid() || index.row() >= m_components.size() || role != Qt::EditRole)
        return false;

    ComponentModel *component = m_components.at(index.row());
    if (!component)
        return false;

    int column = index.column();
    
    if (column == 0) {
        // ID
        bool ok;
        int id = value.toInt(&ok);
        if (ok) {
            component->setId(id);
            emit dataChanged(index, index);
            return true;
        }
    } else if (column == 1) {
        // Designator
        component->setDesignator(value.toString());
        emit dataChanged(index, index);
        return true;
    } else {
        // Свойства компонента
        int propertyIndex = column - 2;
        if (propertyIndex >= 0 && propertyIndex < m_propertyNames.size()) {
            QString propertyName = m_propertyNames.at(propertyIndex);
            QMap<QString, QString> properties = component->properties();
            properties[propertyName] = value.toString();
            component->setProperties(properties);
            emit dataChanged(index, index);
            return true;
        }
    }

    return false;
}

Qt::ItemFlags ComponentTableModel::flags(const QModelIndex &index) const
{
    if (!index.isValid())
        return Qt::NoItemFlags;

    return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;
}

// Методы для работы с компонентами
void ComponentTableModel::addComponent(ComponentModel *component)
{
    if (!component)
        return;

    beginInsertRows(QModelIndex(), m_components.size(), m_components.size());
    m_components.append(component);
    endInsertRows();
}

void ComponentTableModel::removeComponent(int row)
{
    if (row < 0 || row >= m_components.size())
        return;

    beginRemoveRows(QModelIndex(), row, row);
    m_components.removeAt(row);
    endRemoveRows();
}

void ComponentTableModel::clearComponents()
{
    if (m_components.isEmpty())
        return;

    beginRemoveRows(QModelIndex(), 0, m_components.size() - 1);
    m_components.clear();
    endRemoveRows();
}

ComponentModel* ComponentTableModel::getComponent(int row) const
{
    if (row < 0 || row >= m_components.size())
        return nullptr;
    return m_components.at(row);
}

QList<ComponentModel*> ComponentTableModel::getComponents() const
{
    return m_components;
}

// Методы для работы с вариантами
QString ComponentTableModel::currentVariant() const
{
    return m_currentVariant;
}

void ComponentTableModel::setCurrentVariant(const QString &variant)
{
    qDebug() << "ComponentTableModel: Установка текущего варианта:" << variant << "текущий:" << m_currentVariant;

    if (m_currentVariant == variant) {
        qDebug() << "ComponentTableModel: Вариант не изменился, но обновляем свойства";
        updateComponentProperties();
        return;
    }
    
    m_currentVariant = variant;
    updateComponentProperties();
    emit currentVariantChanged();
    qDebug() << "ComponentTableModel: Вариант установлен, испущен сигнал currentVariantChanged";
}

// Методы для работы с именами свойств
QStringList ComponentTableModel::propertyNames() const
{
    return m_propertyNames;
}

void ComponentTableModel::setPropertyNames(const QStringList &newPropertyName)
{

    
    if (m_propertyNames == newPropertyName)
        return;
    
    beginResetModel();
    m_propertyNames = newPropertyName;
    endResetModel();
    emit propertyNamesChanged();
    

}

// Приватные методы
void ComponentTableModel::updateComponentProperties()
{
    qDebug() << "ComponentTableModel: Обновление свойств компонентов для варианта:" << m_currentVariant;

    
    for (ComponentModel *component : m_components) {
        // Принудительно обновляем свойства компонента для текущего варианта
        component->setCurrentVariant(m_currentVariant);
    }
    
    // Уведомляем об изменениях
    if (!m_components.isEmpty()) {
        emit dataChanged(index(0, 0), index(rowCount()-1, columnCount()-1));
    }
    qDebug() << "ComponentTableModel: Свойства обновлены, испущен сигнал dataChanged";
}

QStringList ComponentTableModel::variants() const
{
    return m_variants;
}

void ComponentTableModel::setVariants(const QStringList &newVariants)
{
    if (m_variants == newVariants)
        return;
    m_variants = newVariants;
    emit variantsChanged();
}