source: SMSSender/src/ui/VCMain/vcmain.cpp @ 67:578192d6fe64

#include "vcmain.h"

#include <QSortFilterProxyModel>
#include <QMessageBox>

#include <QCompleter>
#include <QDebug>

#include <algorithm>

#include <snumber.h>
#include <typeconvert.h>

#include <icontact.h>

#include "../../business/BusinessFactory.h"
#include "../../business/BCAccountManager.h"
#include "../../business/BCContactManager.h"
#include "../../business/BCGroupManager.h"

#include "../UIHelper.h"

#include "../VCAccountList/vcaccountlist.h"
#include "../VCAddressBook/vcaddressbook.h"
#include "../VCEditContact/vceditcontact.h"
#include "../VCSettings/vcsettings.h"

#include "../completers/bettercompleter.h"
#include "../models/aliascompletionmodel.h"
#include "../models/loadedaccountmodel.h"

#include "../delegates/aligndelegate.h"


VCMain::VCMain(QWidget *parent): QMainWindow(parent){
        ui.setupUi(this);

        /* Accounts */
        accountModel_       = new AccountTreeModel(this);
        accountFilterModel_ = new LoadedAccountModel(this);
        accountFilterModel_->setSourceModel(accountModel_);
        accountFilterModel_->setSortCaseSensitivity(Qt::CaseInsensitive);
        accountFilterModel_->setDynamicSortFilter(true);
        accountFilterModel_->sort(AccountTreeModel::ColName, Qt::AscendingOrder);
        ui.lstAccounts->setModel(accountFilterModel_);

        /* Contact / Groups */
        contactGroupListModel_ = new ContactGroupListModel(this);
        contactGroupSortModel_ = new QSortFilterProxyModel(this);
        contactGroupSortModel_->setSourceModel(contactGroupListModel_);
        contactGroupSortModel_->setDynamicSortFilter(true);
        contactGroupSortModel_->setSortCaseSensitivity(Qt::CaseInsensitive);
        contactGroupSortModel_->sort(0, Qt::AscendingOrder);
    ui.lstContacts->setModel(contactGroupSortModel_);

        QSortFilterProxyModel* completionModel = new AliasCompletionModel(this);
    completionModel->setSourceModel(contactGroupListModel_);
    BetterCompleter* aliasCompleter = new BetterCompleter(completionModel, this);
    aliasCompleter->setCompletionMode(QCompleter::PopupCompletion);
    aliasCompleter->setCaseSensitivity(Qt::CaseInsensitive);

    ui.lstContacts->setCompleter(aliasCompleter);
    ui.lstContacts->completer()->popup()->setIconSize(QSize(24, 24));

    connect(ui.lstContacts->lineEdit(), SIGNAL(returnPressed()),
            this, SLOT(on_btnAddRecipient_clicked()));

    connect(aliasCompleter, SIGNAL(highlighted(const QString&)),
            this, SLOT(on_lstContacts_completer_changed(const QString&)));


    connect(BCAccountLoadManager::instance(), SIGNAL(accountLoadStateChanged(IAccount*, AccountLoadState)),
            this, SLOT(on_accountLoadStateChanged(IAccount*, AccountLoadState)));
    connect(BCAccountLoadManager::instance(), SIGNAL(accountLoaded(IAccount*)),
            this, SLOT(on_accountLoaded(IAccount*)));
    connect(BCAccountLoadManager::instance(), SIGNAL(accountLoadingFailed(IAccount*, EException*)),
            this, SLOT(on_accountLoadingFailed(IAccount*, EException*)));


    // First "signal" to initialize some slots
    on_treeRecipients_itemSelectionChanged();

        ui.lstContacts->setCurrentIndex(-1);
}

/* Contacts & Recipients... */
bool VCMain::isContactNode(const QTreeWidgetItem* node){
    return nodeToContact.contains(const_cast<QTreeWidgetItem*>(node));
}
bool VCMain::isGroupNode(const QTreeWidgetItem* node){
    return nodeToGroup.contains(const_cast<QTreeWidgetItem*>(node));
}

IContact* VCMain::getContactOfNode(const QTreeWidgetItem* node){
    if (!isContactNode(node)){
        return (IContact*)0;
    } else {
        return nodeToContact[const_cast<QTreeWidgetItem*>(node)];
    }
}
IGroup* VCMain::getGroupOfNode(const QTreeWidgetItem* node){
    if (!isGroupNode(node)){
        return (IGroup*)0;
    } else {
        return nodeToGroup[const_cast<QTreeWidgetItem*>(node)];
    }
}

bool VCMain::isNodeContactOrHasContact(const QTreeWidgetItem* node, IContact* contact){
    if (isContactNode(node)){
        IContact* contact_ = getContactOfNode(node);
        if (contact->id() == contact_->id()){
            return true;
        }
    } else {
        // group...
        for (int x = 0; x < node->childCount(); ++x){
            if (isNodeContactOrHasContact(node->child(x), contact)){
                return true;
            }
        }
    }
    return false;

}

bool VCMain::isContactAlreadyRecipient(IContact* contact){
    return getRecipientContacts(true).contains(contact);
}
bool VCMain::isGroupAlreadyRecipient(IGroup* group){
    return getRecipientGroups().contains(group);
}

QSet<IContact*> VCMain::getRecipientContacts(bool withGroupContacts /* = true */, QTreeWidgetItem* node /* = NULL */) {
    QSet<IContact*> result;

    if (node == NULL) {
        for (int i = 0; i < ui.treeRecipients->topLevelItemCount(); ++i) {
            result.unite(getRecipientContacts(withGroupContacts, ui.treeRecipients->topLevelItem(i)));
        }
    }

    if (isContactNode(node)) {
        result.insert(getContactOfNode(node));
    } else if (withGroupContacts && isGroupNode(node)) {
        for (int i = 0; i < node->childCount(); ++i) {
            result.unite(getRecipientContacts(withGroupContacts, node->child(i)));
        }
    }

    return result;
}

QSet<IGroup*> VCMain::getRecipientGroups() {
    QSet<IGroup*> result;
    for (int x = 0; x < ui.treeRecipients->topLevelItemCount(); ++x){
        if (isGroupNode(ui.treeRecipients->topLevelItem(x))){
            result.insert(getGroupOfNode(ui.treeRecipients->topLevelItem(x)));
        }
    }
    return result;
}


void VCMain::addRecipient(IContact* contact, QTreeWidgetItem* parent /* = NULL */){
    if ((contact == NULL) || isContactAlreadyRecipient(contact)){
        return;
    }

    // TODO: Check if the given recipient/number is a valid recipient for the selected gateway

    contactGroupListModel_->addFilteredContact(contact);

    QTreeWidgetItem* node;
    if (parent) {
        node = new QTreeWidgetItem(parent); // parent->addChild is done in here
    } else {
        node = new QTreeWidgetItem(ui.treeRecipients);
        ui.treeRecipients->addTopLevelItem(node);
    }

    node->setText(0, contact->name());
    node->setIcon(0, QPixmap::fromImage(contact->image()));
    nodeToContact[node] = contact;
}

void VCMain::addRecipient(IGroup* group){
    if ((group == NULL) || isGroupAlreadyRecipient(group)){
        return;
    }

    QTreeWidgetItem* node = new QTreeWidgetItem(ui.treeRecipients);
    ui.treeRecipients->addTopLevelItem(node);

    node->setText(0, group->name());
    node->setIcon(0, QPixmap::fromImage(group->image()));
    nodeToGroup[node] = group;

    foreach (IContact* contact, group->contacts()) {
        addRecipient(contact, node);
    }
}

void VCMain::removeNode(QTreeWidgetItem* node){
    QTreeWidgetItem* parent = node->parent();
    if (parent){
        parent->removeChild(node);

        if (parent->childCount() == 0){
            removeRecipient(parent);
        }
    } else {
        ui.treeRecipients->takeTopLevelItem(ui.treeRecipients->indexOfTopLevelItem(node));
    }
}
void VCMain::removeRecipient(QTreeWidgetItem* node){
    if (isContactNode(node)){
        IContact* contact = nodeToContact[node];
        contactGroupListModel_->removeFilteredContact(contact);

        removeNode(node);
        nodeToContact.remove(node);
    } else { // Group
        for (int x = 0; x < node->childCount(); ++x){
            removeRecipient(node->child(x)); // Remove all contacts of this group
        }

        removeNode(node);
        nodeToGroup.remove(node);
    }
}


void VCMain::reloadAccountList() {
/*    accountStrToAccount.clear();
    QComboBox* accLst = ui.lstAccounts;

    QString selectedAccount = accLst->currentText();

    accLst->clear();
    foreach(IAccount* account, BCAccountManager::instance()->getAccountListByLoadState(Loaded)) {
        accLst->addItem(account->name());
        accountStrToAccount.insert(account->name(), account);
    }

    int index = accLst->findText(selectedAccount);
    index = std::max(index, 0);
    accLst->setCurrentIndex(index);*/
}

void VCMain::enableSendBtnIfAllFilled() {
    ui.btnSend->setEnabled((ui.txtMessage->toPlainText().trimmed() != "")
                           && (ui.treeRecipients->topLevelItemCount() > 0)
                           && (ui.lstAccounts->currentIndex() > -1));
}


void VCMain::clearMessage() {
    ui.txtMessage->clear();
    ui.treeRecipients->clear();
    ui.txtMessage->setFocus();
}

void VCMain::sendMessage() {
    QModelIndex idx            = accountFilterModel_->mapToSource(accountFilterModel_->index(ui.lstAccounts->currentIndex(), 0));
    IAccount* account          = accountModel_->dataObject(idx);
    QString message            = ui.txtMessage->toPlainText().trimmed();
    QSet<IContact*> recipients = getRecipientContacts(true);

    if (account != NULL) {
        account->sendSMS(message, recipients);
        QMessageBox::information(this, tr("SMS sent"), tr("Your sms has successfully been sent."), QMessageBox::Ok, QMessageBox::Ok);
    }
}


/* SLOTS... */

void VCMain::on_btnSend_clicked() {
    sendMessage();
}

void VCMain::on_treeRecipients_itemSelectionChanged(){
    ui.btnRemoveRecipient->setEnabled(ui.treeRecipients->selectedItems().count() > 0);
}

void VCMain::on_lstContacts_completer_changed(const QString& text) {
    qDebug() << text << ui.lstContacts->findText(text);
    ui.lstContacts->setCurrentIndex(ui.lstContacts->findText(text));
}


void VCMain:: on_btnAddRecipient_clicked(){
    QModelIndex idx = contactGroupSortModel_->mapToSource(contactGroupSortModel_->index(ui.lstContacts->currentIndex(), 0));
    if (idx.isValid()) {
        IInterface* recipient = contactGroupListModel_->dataObject(idx);
        addRecipient(dynamic_cast<IContact*>(recipient));
        addRecipient(dynamic_cast<IGroup*>(recipient));
    } else {
        SNumber number = SNumber::fromString(ui.lstContacts->lineEdit()->text().trimmed(), SNumber::GuessFormat);
        if (!number.isValid()) {
            number = SNumber::fromString("+41 " + ui.lstContacts->lineEdit()->text().trimmed(), SNumber::GuessFormat);
        }
        if (number.isValid()) {
            IContact* recipient = BCContactManager::instance()->getContactByNumber(number);

            if (recipient != NULL) {
                addRecipient(recipient);
            } else {
                IContact* recipient = BusinessFactory::instance()->getContactInstance();
                recipient->setNumber(number);

                if (QMessageBox::Yes == QMessageBox::question(this, tr("SMSSender"),
                                                              tr("This number is not yet in your address book. Do you want to add it?"),
                                                              QMessageBox::Yes,
                                                              QMessageBox::No | QMessageBox::Default | QMessageBox::Escape)){
                    VCEditContact* ec = new VCEditContact(recipient, this);
                    if (ec->exec() == QDialog::Accepted){ // Wait for return
                        BCContactManager::instance()->saveContact(recipient);
                    }
                }
                if (recipient->name() == "") {
                    recipient->setName(number.toString(SNumber::IsoFormatShort));
                }
                addRecipient(recipient);
            }
        }
    }
    ui.lstContacts->setCurrentIndex(-1);
    ui.lstContacts->clearEditText();
    enableSendBtnIfAllFilled();
}

void VCMain::on_btnRemoveRecipient_clicked(){
    QListIterator<QTreeWidgetItem*> i(ui.treeRecipients->selectedItems());
    while (i.hasNext()){
        removeRecipient(i.next());
    }
    enableSendBtnIfAllFilled();
}


/* File menu */

void VCMain::on_actionNewMessage_triggered(bool checked) {
    Q_UNUSED(checked);

    clearMessage();
}

/* Edit menu */

void VCMain::on_actionAccounts_triggered(bool checked) {
    Q_UNUSED(checked);

    VCAccountList* cl = new VCAccountList(this);
    cl->show();
}

void VCMain::on_actionAddressBook_triggered(bool checked){
    Q_UNUSED(checked);

    VCAddressBook* cl = new VCAddressBook(this);
    cl->show();
}

void VCMain::on_actionPreferences_triggered(bool checked){
    Q_UNUSED(checked);

    VCSettings* s = new VCSettings(this);
        s->show();
}


/* Help menu */

void VCMain::on_actionAbout_triggered(bool checked){
    Q_UNUSED(checked);

    // TODO: implement about...
}


void VCMain::on_txtMessage_textChanged() {
    enableSendBtnIfAllFilled();
}
void VCMain::on_selAccounts_currentIndexChanged(int index) {
    enableSendBtnIfAllFilled();
}


/* Account loading */
void VCMain::on_accountLoadStateChanged(IAccount* account, AccountLoadState state) {

}

void VCMain::on_accountLoaded(IAccount* account) {
    reloadAccountList();
}

void VCMain::on_accountLoadingFailed(IAccount* account, EException* exception) {
    QMessageBox::critical(this, tr("Error occured"), tr("An unknown error has occured!") + "\n\n" + QString(exception->what()), QMessageBox::Ok, QMessageBox::Ok);
    reloadAccountList();
}