squawk/ui/dialogqueue.cpp

// Squawk messenger. 
// Copyright (C) 2019  Yury Gubich <blue@macaw.me>
// 
// 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 "dialogqueue.h"
#include "squawk.h"
#include <QDebug>

DialogQueue::DialogQueue(Squawk* p_squawk):
    QObject(),
    currentSource(),
    currentAction(none),
    queue(),
    collection(queue.get<0>()),
    sequence(queue.get<1>()),
    prompt(nullptr),
    squawk(p_squawk)
{
}

DialogQueue::~DialogQueue()
{
}

bool DialogQueue::addAction(const QString& source, DialogQueue::Action action)
{
    if (action == none) {
        return false;
    }
    if (currentAction == none) {
        currentAction = action;
        currentSource = source;
        performNextAction();
        return true;
    } else {
        if (currentAction != action || currentSource != source) {
            std::pair<Queue::iterator, bool> result = queue.emplace(source, action);
            return result.second;
        } else {
            return false;
        }
    }
}

bool DialogQueue::cancelAction(const QString& source, DialogQueue::Action action)
{
    if (source == currentSource && action == currentAction) {
        actionDone();
        return true;
    } else {
        Collection::iterator itr = collection.find(ActionId{source, action});
        if (itr != collection.end()) {
            collection.erase(itr);
            return true;
        } else {
            return false;
        }
    }
}

void DialogQueue::performNextAction()
{
    switch (currentAction) {
        case none:
            actionDone();
            break;
        case askPassword:
            prompt = new QInputDialog(squawk);
            connect(prompt, &QDialog::accepted, this, &DialogQueue::onPropmtAccepted);
            connect(prompt, &QDialog::rejected, this, &DialogQueue::onPropmtRejected);
            prompt->setInputMode(QInputDialog::TextInput);
            prompt->setTextEchoMode(QLineEdit::Password);
            prompt->setLabelText(tr("Input the password for account %1").arg(currentSource));
            prompt->setWindowTitle(tr("Password for account %1").arg(currentSource));
            prompt->setTextValue("");
            prompt->exec();
    }
}

void DialogQueue::onPropmtAccepted()
{
    switch (currentAction) {
        case none:
            break;
        case askPassword:
            emit squawk->responsePassword(currentSource, prompt->textValue());
            break;
    }
    actionDone();
}

void DialogQueue::onPropmtRejected()
{
    switch (currentAction) {
        case none:
            break;
        case askPassword:
            emit squawk->disconnectAccount(currentSource);
            break;
    }
    actionDone();
}

void DialogQueue::actionDone()
{
    prompt->deleteLater();
    prompt = nullptr;

    if (queue.empty()) {
        currentAction = none;
        currentSource = "";
    } else {
        Sequence::iterator itr = sequence.begin();
        currentAction = itr->action;
        currentSource = itr->source;
        sequence.erase(itr);
        performNextAction();
    }
}

DialogQueue::ActionId::ActionId(const QString& p_source, DialogQueue::Action p_action):
    source(p_source),
    action(p_action) {}

bool DialogQueue::ActionId::operator < (const DialogQueue::ActionId& other) const
{
    if (action == other.action) {
        return source < other.source;
    } else {
        return action < other.action;
    }
}

DialogQueue::ActionId::ActionId(const DialogQueue::ActionId& other):
    source(other.source),
    action(other.action) {}