source: SMSSender/src/ui/models/accountmodel.cpp @ 43:10dd65d71f7f

#include "accountmodel.h"

#include <QDebug>

AccountModel::AccountModel(QObject* parent)
    : QAbstractTableModel(parent)
{
    connect(BCAccountManager::instance(), SIGNAL(accountAdded(IAccount*)),
            this, SLOT(accountDataChanged(IAccount*)));
    connect(BCAccountManager::instance(), SIGNAL(accountDataChanged(IAccount*)),
            this, SLOT(accountDataChanged(IAccount*)));
    connect(BCAccountManager::instance(), SIGNAL(accountRemoved(IAccount*)),
            this, SLOT(accountDataChanged(IAccount*)));
}
AccountModel::~AccountModel() {
    disconnect(BCAccountManager::instance(), SIGNAL(accountAdded(IAccount*)),
               this, SLOT(accountDataChanged(IAccount*)));
    disconnect(BCAccountManager::instance(), SIGNAL(accountDataChanged(IAccount*)),
               this, SLOT(accountDataChanged(IAccount*)));
    disconnect(BCAccountManager::instance(), SIGNAL(accountRemoved(IAccount*)),
               this, SLOT(accountDataChanged(IAccount*)));
}

void AccountModel::accountUpdated(IAccount* account) {
    int row = BCAccountManager::instance()->getAccountList().values().indexOf(account);

    QModelIndex idx_start = index(row, 0);
    QModelIndex idx_end   = index(row, COL_COUNT);
    emit dataChanged(idx_start, idx_end);
}

QVariant AccountModel::headerData(int section, Qt::Orientation orientation, int role) const {
    if (orientation == Qt::Horizontal) {
        if (role == Qt::DisplayRole) {
            switch (section) {
                case COL_NAME:         return tr("Name");
                case COL_GATEWAY_NAME: return tr("Gateway");
                case COL_ENABLED:      return tr("Enabled");
            }
        }
        if (role == Qt::TextAlignmentRole) {
            return Qt::AlignLeft + Qt::AlignVCenter;
        }
    }
    return QAbstractTableModel::headerData(section, orientation, role);
}

IAccount* AccountModel::dataObject(const QModelIndex& index) const {
    return BCAccountManager::instance()->getAccountList().values().at(index.row());
}

QVariant AccountModel::data(const QModelIndex& index, int role) const {
    QList<IAccount*> accounts = BCAccountManager::instance()->getAccountList().values();
    if (!index.isValid() || index.row() < 0 || index.row() >= accounts.size())
        return QVariant();

    const IAccount* account = accounts.at(index.row());

    if (role == Qt::DisplayRole) {
        switch (index.column()) {
            case COL_NAME:
                return account->name();
            case COL_GATEWAY_NAME:
                return account->gateway()->name();
        }
    }
    if (role == Qt::CheckStateRole) {
        switch (index.column()) {
            case COL_ENABLED:
                return (account->isEnabled()) ? Qt::Checked : Qt::Unchecked;
        }
    }
    if (role == Qt::DecorationRole) {
        switch (index.column()) {
            case COL_GATEWAY_NAME:
                return account->gateway()->icon();
        }
    }

    if (role == Qt::TextAlignmentRole) {
        switch (index.column()) {
            case COL_NAME:
            case COL_GATEWAY_NAME:
                return Qt::AlignLeft + Qt::AlignVCenter;
            case COL_ENABLED:
                return Qt::AlignCenter + Qt::AlignVCenter;
        }
    }

    return QVariant();
}

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

    Qt::ItemFlags flags = QAbstractTableModel::flags(index);
    if (index.column() == COL_ENABLED)
        flags |= Qt::ItemIsUserCheckable;
    return flags;
}

bool AccountModel::setData(const QModelIndex& index, const QVariant& value, int role /* = Qt::EditRole */) {
    if (!index.isValid()) {
        return false;
    }

    if (role == Qt::CheckStateRole) {
        if (index.column() == COL_ENABLED) {
            IAccount* account = dataObject(index);
            Q_ASSERT(account);

            const Qt::CheckState cs = static_cast<Qt::CheckState>(value.toInt());
            account->setEnabled(cs != Qt::Unchecked);
            BCAccountManager::instance()->saveAccount(account);

            return true;
        }
    }

    return false;
}

int AccountModel::columnCount(const QModelIndex& parent) const {
    return (parent.isValid()) ? 0 : COL_COUNT;
}

int AccountModel::rowCount(const QModelIndex& parent) const {
    return (parent.isValid()) ? 0 : BCAccountManager::instance()->getAccountList().count();
}

bool AccountModel::removeRows(int row, int count, const QModelIndex& parent) {
    if (parent.isValid())
        return false;

    int lastRow = row + count - 1;
    beginRemoveRows(parent, row, lastRow);
    QList<IAccount*> accounts = BCAccountManager::instance()->getAccountList().values();
    for (int i = lastRow; i >= row; --i) {
        BCAccountManager::instance()->removeAccount(accounts.at(i)->id());
    }
    endRemoveRows();
    return true;
}