source: qutecom-coip/gui/src/account/accountmonitoritem.cpp @ 286:dc0e36586866

#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)
{       
    _hideTimer = 0;
    _animationTimer = 0;
    
    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)
                        {
                stopAnimationTimer();
                                ui->pushButtonPresence->setText("disconnected");
                QPixmap pix = Pix::getPresencePix(EnumPresenceState::PresenceStateOffline);
                ui->labelPresence->setPixmap(pix);
                                show();
                        }
                        else if( state == EnumConnectionState::ConnectionStateConnected)
                        {
                stopAnimationTimer();
                                ui->pushButtonPresence->setText("connected");
                QPixmap pix = Pix::getPresencePix(account->getPresenceState());
                ui->labelPresence->setPixmap(pix);
                                startHideTimer();
                        }
                }
        }
}

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)
                {
            stopAnimationTimer();
                        ui->pushButtonPresence->setText("Error");
            QPixmap pix = Pix::getPresencePix(EnumPresenceState::PresenceStateOffline);
                        ui->labelPresence->setPixmap(pix);
                        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)
                {
            startAnimationTimer();
                        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 && _animationTimer == 0)
                {
                        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::startAnimationTimer()
{
    if(_animationTimer == 0)
        _animationTimer = startTimer(50);
}

void AccountMonitorItem::stopAnimationTimer()
{
    if (_animationTimer > 0)
    {
        killTimer(_animationTimer);
        _animationTimer = 0;
    }
}

void AccountMonitorItem::startHideTimer()
{
    if(_hideTimer == 0)
        _hideTimer = startTimer(1500);
}
void AccountMonitorItem::stopHideTimer()
{
    if (_hideTimer > 0)
    {
        killTimer(_hideTimer);
        _hideTimer = 0;
    }
}

void AccountMonitorItem::timerEvent(QTimerEvent *e)
{
        if(e->timerId() == _hideTimer)
        {
                stopHideTimer();
                hide();
        }
    else if(e->timerId() == _animationTimer)
    {
        QTransform transform;
        transform.rotate(_angle);
        QPixmap pix = QPixmap(":/account/loading.png").transformed(transform,Qt::SmoothTransformation).scaled(9,9);
        ui->labelPresence->setPixmap(pix);
        _angle += 10;
    }
}