Две модели в одном QTableView Опции

[madnessw]

Всем привет!
Поставили передомной задачу отображение нескольких моделей в одном TableView
Количество строк в моделях одинаковое.
решил написать общую модель QBigModel

#include "qbigmodel.h"

QBigModel::QBigModel(shared_ptr<EstData> eData,QObject *parent)
    : QBaseModel(parent)
{
    ESSData = eData;
    LaD = new QLoadAndGenerationTableModel(eData,this);
    VM = new QVoltageTableModel(eData,this);
}

QBigModel::~QBigModel()
{

}

QVariant QBigModel::headerData( int section, Qt::Orientation orientation, int role ) const
{
    if (section<LaD->columnCount())
    {
        return LaD->headerData(section,orientation,role);
    } else
    {
        return VM->headerData(section-LaD->columnCount(),orientation,role);
    }
}

Qt::ItemFlags QBigModel::flags( const QModelIndex &index ) const
{
    if (index.column()<LaD->columnCount())
    {
        return LaD->flags(index);
    } else
    {
        return VM->flags(index);
    }
}

QModelIndex QBigModel::index( int row, int column, const QModelIndex &parent /*= QModelIndex()*/ ) const
{
    if (column<LaD->columnCount())
    {
        return LaD->index(row,column);
    } else
    {
        return VM->index(row,column-LaD->columnCount());
    }
}

QModelIndex QBigModel::parent( const QModelIndex &child ) const
{
    if (child.column()<LaD->columnCount())
    {
        return LaD->parent(child);
    } else
    {
        return VM->parent(child);
    }
}

int QBigModel::rowCount( const QModelIndex &parent /*= QModelIndex()*/ ) const
{
    return ESSData->NodeVklCount+1;
}

int QBigModel::columnCount( const QModelIndex &parent /*= QModelIndex()*/ ) const
{
    return VM->columnCount()+LaD->columnCount();
}

QVariant QBigModel::data( const QModelIndex &index, int role /*= Qt::DisplayRole*/ ) const
{
    if (index.column()<LaD->columnCount())
    {
        return LaD->data(index,role);
    } else
    {
        return VM->data(index,role);
    }
}

bool QBigModel::setData( const QModelIndex &index, const QVariant &value, int role /*= Qt::EditRole*/ ) const
{
    if (index.column()<LaD->columnCount())
    {
        return LaD->setData(index,value,role);
    } else
    {
        return VM->setData(index,value,role);
    }
}

Данные отображаются но не редактируются : Qt:editRole не отрабатывает - голову сломал не могу понять в чём дело причём в ообычной модели всё работает:

#include "qvoltagetablemodel.h"
#include <QStringList>
#include <QFont>
QVoltageTableModel::QVoltageTableModel(shared_ptr<EstData>  eData, QObject *parent)
    :QBaseModel(parent)
{
    ESSData = eData;
}

QVoltageTableModel::~QVoltageTableModel()
{
    
}

//Возвращает шапку таблицы
QVariant QVoltageTableModel::headerData(int section, Qt::Orientation orientation,
                                     int role) const
{
     if (role != Qt::DisplayRole)
         return QVariant();

    if (orientation == Qt::Horizontal)
    {
        switch (section)
        {
//         case 0: return tr("Number"); break;
//         case 1: return tr("Node name"); break;
        case 0:    return " ";break;
        case 1: return tr("U measured"); break;
        case 2: return tr("U estimated"); break;
        case 3:return tr("Angele U"); break;
        case 4: return tr("D[U]"); break;
        case 5: return tr("Error U"); break;
        }
    }
    return QString();
}

//Делаем некоторые колонки редактируемые
Qt::ItemFlags QVoltageTableModel::flags(const QModelIndex &index) const
{
     if (index.isValid())
         if ((index.column()==4)||(index.column()==0)||(index.column()==1))
         {
            return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
         } 
        else
         if ((index.column()==5)||(index.column()==3)||(index.column()==2)) 
         {
            return QAbstractItemModel::flags(index) | Qt::DisplayRole;
         }
    return Qt::ItemIsEnabled;
}


QModelIndex QVoltageTableModel::index(int row, int column,
                          const QModelIndex &parent) const
{
    return createIndex(row,column);
}
QModelIndex QVoltageTableModel::parent(const QModelIndex &child) const
{
    return QModelIndex();
}
int QVoltageTableModel::rowCount(const QModelIndex &parent) const
{
    if (ESSData->NodeVklCount<=0)
    {
        return 0;
    }
    return ESSData->NodeVklCount+1;
}
int QVoltageTableModel::columnCount(const QModelIndex &parent) const
{
    return 6;
}
QVariant QVoltageTableModel::data(const QModelIndex &index, int role) const
{
    //QVariant v = GetValue<double>(ESSData->D_U,ESSData->NL[index.row()]);
    if (role == Qt::DisplayRole)
    {
        switch (index.column())
        {
            
//             case 0: 
//                     {
//                         return GetValue(ESSData->NN,index.row()+1);
//                         break;
//                     }
//             case 1: 
//                 {
//                     return QString::fromStdString(ESSData->NodeName[index.row()+1]);
//                     break;
//                 }

            case 0: 
                {
                    
                        int sts = GetValue(ESSData->Status_U,index.row()+1).toInt();
                        //QString s =  statusToText(sts);
                        return statusToText(sts);
                        break;
                }

            case 1: 
                    {
                        int b = GetValue(ESSData->Status_U,index.row()+1).toInt()&tm_NotIdentTM;
                        if (b!=0)
                        {
                            return QVariant("");
                        }
                        b = GetValue(ESSData->Status_U,index.row()+1).toInt()&tm_Manual;
                        if (b==0)    
                            return GetValue(ESSData->U_meas,index.row()+1); 
                        else 
                            return GetValue(ESSData->U_man,index.row()+1); 
                        break;
                    }
            case 2: 
                {
                    return GetValue(ESSData->U_est,index.row()+1); 
                    break;
                }
            case 3: 
                {
                    return GetValue(ESSData->AngleU_est,index.row()+1); 
                    break;
                }
            case 4: 
                    {
                        return GetValue(ESSData->D_U,index.row()+1); 
                        break;
                    }
            case 5: 
                    {
                        return GetValue(ESSData->Error_U,index.row()+1);
                        break;
                    }
        }

    }
    
      if (role == Qt::ItemIsEditable)
      {
        switch (index.column())
        {
        case 0:
            {
                    unsigned int sts = GetValue(ESSData->Status_U,index.row()+1).toUInt();
                    return GetValue(ESSData->Status_U,index.row()+1).toUInt();
                    break;
            }
        case 1: 
            {
                int b = GetValue(ESSData->Status_U,index.row()+1).toInt()&tm_NotIdentTM;
                if (b!=0)
                {
                    return QVariant("");
                }
                b = GetValue(ESSData->Status_U,index.row()+1).toInt()&tm_Manual;
                if (b==0)    
                    return GetValue(ESSData->U_meas,index.row()+1); 
                else 
                    return GetValue(ESSData->U_man,index.row()+1); 
                break;
            }
        case 4: 
            {
                return GetValue(ESSData->D_U,index.row()+1); 
                break;
            }
        }

    }

    if (role == Qt::TextColorRole)
    {
        if (GetValue(ESSData->BranState,index.row()+1).toInt()!=BRAN_STATE_ON)
        {
            return QColor(Qt::lightGray);
        }
        switch (index.column())
        {
        case 1:
            {
                QString sts = statusToText(GetValue(ESSData->Status_U,index.row()+1).toInt());
                return getStatusTextColor(sts);
                break;
            }
        }
    }
    if (role == Qt::FontRole)
    {
        if (GetValue(ESSData->BranState,index.row()+1).toInt()!=BRAN_STATE_ON)
        {
            QFont font;
            font.setBold(true);
            return font;
        }

        switch (index.column())
        {
        case 1:
            {
                QString sts = statusToText(GetValue(ESSData->Status_U,index.row()+1).toInt());
                if ((sts=="N")||(sts=="#"))
                {
                    QFont font;
                    font.setBold(true);
                    return font;
                }
                break;
            }
        }
    }
    return QVariant();
        
}

bool QVoltageTableModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    
    if (index.isValid() && role ==Qt::EditRole)
    {
        switch (index.column())
        {
        case 0:{
                    //int sts = textToStatus(index.data().toString(),GetValue(ESSData->Status_U,index.row()+1).toInt());
                    setValue(ESSData->Status_U,index.row()+1,value.toUInt()); 
                    emit dataChanged(index, index);
                    return true;
                    break;
               }
        case 1: 
            {
                int sts = GetValue(ESSData->Status_U,index.row()+1).toInt();
                sts&=tm_NotEstManualFlags;
                sts=sts|tm_Manual;
                setValue(ESSData->Status_U,index.row()+1,sts);
                setValue(ESSData->U_man,index.row()+1,value);
                emit dataChanged(index, index);
                return true;
                break;
            }
        case 4:{
                    setValue(ESSData->D_U,index.row()+1,value); 
                    emit dataChanged(index, index);
                    return true;
                    break;
               }
        }
    }
    return false;
}

Почему роль редактирования не отрабатывает?))
Ну или кто подскажет как проще такое зделать)