source: qutecom-coip/gui/src/account/accountmonitoritem.cpp @ 283:312974380d4f

#include <account/accountmonitoritem.h>
#include <ui_accountmonitoritem.h>
#include <util/pix.h>

AccountMonitorItem::AccountMonitorItem(std::string accountdId, QWidget *parent) 
:QWidget(parent),ui(new Ui::AccountMonitorItem),_accountId(accountdId)
{       
    QPalette pal = palette();
    pal.setBrush(backgroundRole(), pal.dark());
    setPalette(pal);
    
    ui->setupUi(this);
    ui->labelIdentity->setPalette(pal);
    ui->labelPresence->setPalette(pal);
        
        QMenu * _menu = new QMenu;
        connect(_menu->addAction(QIcon(":/presence/online.png"),tr("Online")),SIGNAL(triggered()),this,SLOT(onlineClicked()));
        connect(_menu->addAction(QIcon(":/presence/away.png"),tr("Away")),SIGNAL(triggered()),this,SLOT(awayClicked()));
        connect(_menu->addAction(QIcon(":/presence/donotdisturb.png"),tr("Do not disturb")),SIGNAL(triggered()),this,SLOT(doNotDisturbClicked()));
        connect(_menu->addAction(QIcon(":/presence/invisible.png"),tr("Invisible")),SIGNAL(triggered()),this,SLOT(invisibleClicked()));
        connect(_menu->addAction(QIcon(":/presence/offline.png"),tr("Offline")),SIGNAL(triggered()),this,SLOT(offlineClicked()));
        
        ui->labelPresence->setText("");
        ui->pushButtonPresence->setText("disconnected");
        ui->pushButtonPresence->setMenu(_menu);
        
        AccountList accountList = Coip::self()->getTUserProfileManager().getCopyOfUserProfile().getAccountList();
        Account * account = AccountListHelper::getCopyOfAccount(accountList, _accountId);
        if(account)
                ui->labelIdentity->setText(QString::fromStdString(account->getLogin()));
        
        connect(&Coip::self()->getTConnectManager(),
                        SIGNAL(accountConnectionStateSignal(std::string, EnumConnectionState::ConnectionState)),this,
                        SLOT(accountConnectionStateSlot(std::string, EnumConnectionState::ConnectionState)));
        connect(&Coip::self()->getTConnectManager(),
                        SIGNAL(accountConnectionErrorSignal(std::string, EnumConnectionError::ConnectionError)),this,
                        SLOT(accountConnectionErrorSlot(std::string, EnumConnectionError::ConnectionError)));
        connect(&Coip::self()->getTConnectManager(),
                        SIGNAL(accountConnectionProgressSignal(std::string, unsigned, unsigned, std::string)),this,
                        SLOT(accountConnectionProgressSlot(std::string, unsigned, unsigned, std::string)));
        
        connect(&Coip::self()->getTUserProfileManager().getTAccountManager(), 
                        SIGNAL(accountAddedSignal(std::string)),this,
                        SLOT(accountAddedSlot(std::string)));
        
        connect(&Coip::self()->getTUserProfileManager().getTAccountManager(), 
                        SIGNAL(accountRemovedSignal(std::string)),this,
                        SLOT(accountRemovedSlot(std::string)));
        
        connect(&Coip::self()->getTUserProfileManager().getTAccountManager(), 
                        SIGNAL(accountUpdatedSignal(std::string,EnumUpdateSection::UpdateSection)),this,
                        SLOT(accountUpdatedSlot(std::string,EnumUpdateSection::UpdateSection)));
}

AccountMonitorItem::~AccountMonitorItem()
{
        delete ui;
}

void AccountMonitorItem::accountConnectionStateSlot(std::string accountId, EnumConnectionState::ConnectionState state)
{
        if( _accountId == accountId )
        {
                AccountList accountList = Coip::self()->getTUserProfileManager().getCopyOfUserProfile().getAccountList();
                Account * account = AccountListHelper::getCopyOfAccount(accountList, accountId);
                if(account)
                {
                        if( state == EnumConnectionState::ConnectionStateDisconnected)
                        {
                                ui->pushButtonPresence->setText("disconnected");
                                show();
                        }
                        else if( state == EnumConnectionState::ConnectionStateConnected)
                        {
                                ui->pushButtonPresence->setText("connected");
                                _hideTimer = startTimer(1500);
                        }
                }
        }
}

void AccountMonitorItem::accountConnectionErrorSlot(std::string accountId, EnumConnectionError::ConnectionError errorCode)
{
        if( _accountId == accountId )
        {
                AccountList accountList = Coip::self()->getTUserProfileManager().getCopyOfUserProfile().getAccountList();
                Account * account = AccountListHelper::getCopyOfAccount(accountList, accountId);
                if(account)
                {
                        ui->pushButtonPresence->setText("Error");
                        show();
                }
        }
}

void AccountMonitorItem::accountConnectionProgressSlot(std::string accountId, unsigned currentStep, unsigned totalSteps, std::string infoMessage)
{
        if( _accountId == accountId )
        {
                AccountList accountList = Coip::self()->getTUserProfileManager().getCopyOfUserProfile().getAccountList();
                Account * account = AccountListHelper::getCopyOfAccount(accountList, accountId);
                if(account)
                {
                        ui->pushButtonPresence->setText("registering");
                        show();
                }
        }
}

void AccountMonitorItem::accountAddedSlot(std::string accountId)
{
        
}

void AccountMonitorItem::accountRemovedSlot(std::string accountId)
{
        
}

void AccountMonitorItem::accountUpdatedSlot(std::string accountId, EnumUpdateSection::UpdateSection section)
{
        if( _accountId == accountId )
        {
                AccountList accountList = Coip::self()->getTUserProfileManager().getCopyOfUserProfile().getAccountList();
                Account * account = AccountListHelper::getCopyOfAccount(accountList, accountId);
                if(account)
                {
                        QPixmap pix = Pix::getPresencePix(account->getPresenceState());
                        ui->labelPresence->setPixmap(pix);
                }
        }
}

void AccountMonitorItem::updatePresenceState(EnumPresenceState::PresenceState presenceState)
{               
        AccountList accountList = Coip::self()->getTUserProfileManager().getCopyOfUserProfile().getAccountList();
        Account * account = AccountListHelper::getCopyOfAccount(accountList, _accountId);
        if(account)
        {
                
                account->setPresenceState(presenceState);
                Coip::self()->getTUserProfileManager().getTAccountManager().update(*account,EnumUpdateSection::UpdateSectionPresenceState);
                
                if(presenceState == EnumPresenceState::PresenceStateOffline)
                {
                        Coip::self()->getTConnectManager().disconnect(account->getUUID());
                }
                else
                {
                        if(account->getConnectionState() != EnumConnectionState::ConnectionStateConnected)
                        {
                                Coip::self()->getTConnectManager().connect(account->getUUID());
                        }
                }
        }
}

void AccountMonitorItem::onlineClicked()
{
        updatePresenceState(EnumPresenceState::PresenceStateOnline);
}

void AccountMonitorItem::awayClicked()
{
        updatePresenceState(EnumPresenceState::PresenceStateAway);
}

void AccountMonitorItem::doNotDisturbClicked()
{
        updatePresenceState(EnumPresenceState::PresenceStateDoNotDisturb);
}

void AccountMonitorItem::invisibleClicked()
{
        updatePresenceState(EnumPresenceState::PresenceStateInvisible);
}

void AccountMonitorItem::offlineClicked()
{
        updatePresenceState(EnumPresenceState::PresenceStateOffline);
}

void AccountMonitorItem::changeEvent(QEvent *e)
{
    QWidget::changeEvent(e);
    switch (e->type()) {
    case QEvent::LanguageChange:        
        break;
    default:
        break;
    }
}

void AccountMonitorItem::timerEvent(QTimerEvent *e)
{
        if(e->timerId() == _hideTimer)
        {
                killTimer(_hideTimer);
                hide();
        }
}