Qt::ForegroundRole);

        setData(index(i, COLUMN_VISIBILITY),

                other.data(other.index(i, COLUMN_VISIBILITY), Qt::CheckStateRole),

                Qt::CheckStateRole);

    }

}

ChannelInfoModel::ChannelInfoModel(const QStringList& channelNames) :

    ChannelInfoModel(channelNames.length(), NULL)

{

    for (int i = 0; i < channelNames.length(); i++)

    {

        setData(index(i, COLUMN_NAME), channelNames[i], Qt::EditRole);

    }

}

ChannelInfoModel::ChannelInfo::ChannelInfo(unsigned index)

{

    name = tr("Channel %1").arg(index + 1);

    visibility = true;

    color = colors[index % NUMOF_COLORS];

}

QString ChannelInfoModel::name(unsigned i) const

{

    return infos[i].name;

}

QColor ChannelInfoModel::color(unsigned i) const

{

    return infos[i].color;

}

bool ChannelInfoModel::isVisible(unsigned i) const

{

    return infos[i].visibility;

}

QStringList ChannelInfoModel::channelNames() const

{

    QStringList r;

    for (unsigned ci = 0; ci < _numOfChannels; ci++)

    {

        r << name(ci);

    }

    return r;

}

int ChannelInfoModel::rowCount(const QModelIndex &parent) const

{

    return _numOfChannels;

}

int ChannelInfoModel::columnCount(const QModelIndex & parent) const

{

    return COLUMN_COUNT;

}

Qt::ItemFlags ChannelInfoModel::flags(const QModelIndex &index) const

{

    if (index.column() == COLUMN_NAME)

    {

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

    }

    else if (index.column() == COLUMN_VISIBILITY)

    {

        return Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemNeverHasChildren | Qt::ItemIsSelectable;

    }

    return Qt::NoItemFlags;

}

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

{

    // check index

    if (index.row() >= (int) _numOfChannels || index.row() < 0)

    {

        return QVariant();

    }

    // get color

    if (role == Qt::ForegroundRole)

    {

        return infos[index.row()].color;

    }

    // get name

    if (index.column() == COLUMN_NAME)

    {

        if (role == Qt::DisplayRole || role == Qt::EditRole)

        {

            return QVariant(infos[index.row()].name);

        }

    } // get visibility

    else if (index.column() == COLUMN_VISIBILITY)

    {

        if (role == Qt::CheckStateRole)

        {

            bool visible = infos[index.row()].visibility;

            return visible ? Qt::Checked : Qt::Unchecked;

        }

    }

    return QVariant();

}

QVariant ChannelInfoModel::headerData(int section, Qt::Orientation orientation, int role) const

{

    if (orientation == Qt::Horizontal)

    {

        if (role == Qt::DisplayRole)

        {

            if (section == COLUMN_NAME)

            {

                return tr("Channel");

            }

            else if (section == COLUMN_VISIBILITY)

            {

                return tr("Visible");

            }

        }

    }

    else                        // vertical

    {

        if (section < (int) _numOfChannels && role == Qt::DisplayRole)

        {

            return QString::number(section + 1);

        }

    }

    return QVariant();

}

bool ChannelInfoModel::setData(const QModelIndex &index, const QVariant &value, int role)

{

    // check index

    if (index.row() >= (int) _numOfChannels || index.row() < 0)

    {

        return false;

    }

    // set color

    if (role == Qt::ForegroundRole)

    {

        infos[index.row()].color = value.value<QColor>();

        emit dataChanged(index, index, QVector<int>({Qt::ForegroundRole}));

        return true;

    }

    // set name

    if (index.column() == COLUMN_NAME)

    {

        if (role == Qt::DisplayRole || role == Qt::EditRole)

        {

            infos[index.row()].name = value.toString();

            emit dataChanged(index, index, QVector<int>({role}));

            return true;

        }

    } // set visibility

    else if (index.column() == COLUMN_VISIBILITY)

    {

        if (role == Qt::CheckStateRole)

        {

            bool checked = value.toInt() == Qt::Checked;

            infos[index.row()].visibility = checked;

            emit dataChanged(index, index, QVector<int>({role}));

            return true;

        }

    }

    // invalid index/role

    return false;

}

void ChannelInfoModel::setNumOfChannels(unsigned number)

{

    if (number == _numOfChannels) return;

    bool isInserting = number > _numOfChannels;

    if (isInserting)

    {

        beginInsertRows(QModelIndex(), _numOfChannels, number-1);

    }

    else

    {

        beginRemoveRows(QModelIndex(), number, _numOfChannels-1);

    }

    // we create channel info but never remove channel info to

    // remember user entered info

    if ((int) number > infos.length())

    {

        {

            infos.append(ChannelInfo(ci));

        }

    }

    // make sure newly available channels are visible, we don't

    // remember visibility option intentionally so that user doesn't

    // get confused

    if (number > _numOfChannels)

    {

        for (unsigned ci = _numOfChannels; ci < number; ci++)

        {

            infos[ci].visibility = true;

        }

    }

    _numOfChannels = number;

    if (isInserting)

    {

        endInsertRows();

    }

    else

    {

        endRemoveRows();

    }

}

void ChannelInfoModel::resetInfos()

{

    beginResetModel();

    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

    {

        infos[ci] = ChannelInfo(ci);

    }

    endResetModel();

}

void ChannelInfoModel::resetNames()

{

    beginResetModel();

    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

    {

        infos[ci].name = ChannelInfo(ci).name;

    }

    endResetModel();

}

void ChannelInfoModel::resetColors()

{

    beginResetModel();

    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

    {

        infos[ci].color = ChannelInfo(ci).color;

    }

    endResetModel();

}

void ChannelInfoModel::resetVisibility()

{

    beginResetModel();

    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

    {

        infos[ci].visibility = true;

    }

    endResetModel();

}

void ChannelInfoModel::saveSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Channels);

    settings->beginWriteArray(SG_Channels_Channel);

    // save all channel information regardless of current number of channels

    for (unsigned ci = 0; (int) ci < infos.length(); ci++)

    {

        settings->setArrayIndex(ci);

        settings->setValue(SG_Channels_Name, infos[ci].name);

        settings->setValue(SG_Channels_Color, infos[ci].color);

        settings->setValue(SG_Channels_Visible, infos[ci].visibility);

    }

    settings->endArray();

    settings->endGroup();

}

void ChannelInfoModel::loadSettings(QSettings* settings)

{

    settings->beginGroup(SettingGroup_Channels);

    unsigned size = settings->beginReadArray(SG_Channels_Channel);

    for (unsigned ci = 0; ci < size; ci++)

    {

        settings->setArrayIndex(ci);

        ChannelInfo chanInfo(ci);

        chanInfo.name       = settings->value(SG_Channels_Name, chanInfo.name).toString();

        chanInfo.color      = settings->value(SG_Channels_Color, chanInfo.color).value<QColor>();

        chanInfo.visibility = settings->value(SG_Channels_Visible, true).toBool();

        if ((int) ci < infos.size())

        {

            infos[ci] = chanInfo;

            if (ci < _numOfChannels)

            {

                auto roles = QVector<int>({

                    Qt::DisplayRole, Qt::EditRole, Qt::ForegroundRole, Qt::CheckStateRole});

                emit dataChanged(index(ci, 0), index(ci, COLUMN_COUNT-1), roles);

            }

        }

        else

        {

            infos.append(chanInfo);

        }

    }

    settings->endArray();

    settings->endGroup();

}