source: SMSSender/frontend/gui/ui/models/contactgroupmodel.cpp @ 315:e6c8bb244ecd

/*
 smssender - A frontend for fast and easy SMS sending over different gateways.
 Copyright (C) 2007-2012, gorrión. See http://smssender.gorrion.ch

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include "contactgroupmodel.h"

#include <QDebug>
#include <QIcon>

namespace UI {

ContactGroupListModel::ContactGroupListModel(QObject* parent, const ContactManager &contactManager,
                                             const GroupManager &groupManager)
    : QAbstractListModel(parent)
    , m_contactManager(contactManager)
    , m_groupManager(groupManager)
{
    connect(&m_contactManager, SIGNAL(contactAdded(SContact*)),
            this, SLOT(onListAltered()));
    connect(&m_contactManager, SIGNAL(contactUpdated(SContact*)),
            this, SLOT(onDataUpdated(SContact*)));
    connect(&m_contactManager, SIGNAL(contactRemoved(SContact*)),
            this, SLOT(onListAltered()));

    connect(&m_groupManager, SIGNAL(groupAdded(SGroup*)),
            this, SLOT(onListAltered()));
    connect(&m_groupManager, SIGNAL(groupUpdated(SGroup*)),
            this, SLOT(onDataUpdated(SGroup*)));
    connect(&m_groupManager, SIGNAL(groupRemoved(SGroup*)),
            this, SLOT(onListAltered()));

    reloadList();
}

void ContactGroupListModel::onListAltered() {
    reloadList();
}

void ContactGroupListModel::onDataUpdated(SContact* contact) {
    dataUpdated(contact);
}
void ContactGroupListModel::onDataUpdated(SGroup *group) {
    dataUpdated(group);
}
void ContactGroupListModel::dataUpdated(const ContactGroupContainer& container) {
    int row = m_items.indexOf(container);

    QModelIndex idx1 = index(row, 0);
    QModelIndex idx2 = index(row, columnCount());

    if (idx1.isValid() && idx2.isValid()) { // Contact/group in list
        emit dataChanged(idx1, idx2);
    }
}

void ContactGroupListModel::reloadList() {
    m_items.clear();
    foreach(SContact *contact, m_contactManager.contacts()) {
        m_items.append(contact);
    }
    foreach(SGroup *group, m_groupManager.groups()) {
        m_items.append(group);
    }

    reset();
}

void ContactGroupListModel::addFilteredContact(const SContact& contact) {
    m_filteredItems.insert(&contact);
    m_items.removeAll(&contact);

    /* Filter groups, from whose all contacts are filtered */
    foreach (const SGroup* group, groups()) {
        bool hasUnfilteredContacts = false;
        foreach (const SContact* contact, group->contacts()) {
            if (m_items.contains(contact)) {
                hasUnfilteredContacts = true;
                break;
            }
        }
        if (!hasUnfilteredContacts) {
            /* Add filtered Group */
            m_filteredItems.insert(group);
            m_items.removeAll(group);
        }
    }

    reset();
}
void ContactGroupListModel::removeFilteredContact(const SContact& contact) {
    m_items.append(&contact);
    m_filteredItems.remove(&contact);

    /* Remove filter from groups, when all its contacts are unfiltered */
    foreach (const SGroup* group, filteredGroups()) {
        bool hasFilteredContacts = false;
        foreach (const SContact* contact, group->contacts()) {
            if (m_filteredItems.contains(contact)) {
                hasFilteredContacts = true;
                break;
            }
        }
        if (!hasFilteredContacts) {
            /* Remove filtered group */
            m_items.append(group);
            m_filteredItems.remove(group);
        }
    }

    reset();
}

ContactGroupContainer ContactGroupListModel::dataObject(const QModelIndex& index) const {
    if (!index.isValid() || (index.row() >= m_items.size())) {
        return ContactGroupContainer();
    } else {
        return m_items.at(index.row());
    }
}

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

    const ContactGroupContainer& container = m_items.at(index.row());
    switch (role) {
        case Qt::DisplayRole:
            if (container.contact) {
                const SContact *contact = container.contact;
                QString contactStr = contact->name();
                QString aliasStr = contact->aliases().join(", ");
                if (!aliasStr.isEmpty()) {
                    contactStr += " (" + aliasStr + ")";
                }
                return contactStr;
            } else {
                const SGroup *group = container.group;
                return "<" + group->name() + ">";
            }
            break;

        case Qt::EditRole:
            if (container.contact) {
                return container.contact->name();
            } else {
                return container.group->name();
            }
            break;

        case Qt::DecorationRole:
            QImage img;
            if (container.contact) {
                img = container.contact->image();
            } else {
                img = container.group->image();
            }

            return QIcon(QPixmap::fromImage(img));
    }

    return QVariant();
}

QSet<const SGroup*> ContactGroupListModel::groups() const {
    QSet<const SGroup*> result;
    foreach (const ContactGroupContainer& c, m_items) {
        if (c.group) {
            result.insert(c.group);
        }
    }
    return result;
}
QSet<const SContact*> ContactGroupListModel::contacts() const {
    QSet<const SContact*> result;
    foreach (const ContactGroupContainer& c, m_items) {
        if (c.contact) {
            result.insert(c.contact);
        }
    }
    return result;
}
QSet<const SGroup*> ContactGroupListModel::filteredGroups() const {
    QSet<const SGroup*> result;
    foreach (const ContactGroupContainer& c, m_filteredItems) {
        if (c.group) {
            result.insert(c.group);
        }
    }
    return result;
}
QSet<const SContact*> ContactGroupListModel::filteredContacts() const {
    QSet<const SContact*> result;
    foreach (const ContactGroupContainer& c, m_filteredItems) {
        if (c.contact) {
            result.insert(c.contact);
        }
    }
    return result;
}


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

int ContactGroupListModel::rowCount(const QModelIndex& parent) const {
    return (parent.isValid()) ? 0 : m_items.count();
}

} // namespace UI