diff --git a/src/qt/walletcontroller.cpp b/src/qt/walletcontroller.cpp
index 0bb1df770..919db0872 100644
--- a/src/qt/walletcontroller.cpp
+++ b/src/qt/walletcontroller.cpp
@@ -1,320 +1,321 @@
// Copyright (c) 2019 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <qt/walletcontroller.h>
#include <qt/askpassphrasedialog.h>
#include <qt/createwalletdialog.h>
#include <qt/guiconstants.h>
#include <qt/guiutil.h>
#include <interfaces/handler.h>
#include <interfaces/node.h>
#include <util/string.h>
#include <util/translation.h>
#include <wallet/wallet.h>
#include <QApplication>
#include <QMutexLocker>
#include <QTimer>
#include <QWindow>
#include <algorithm>
WalletController::WalletController(interfaces::Node &node,
const PlatformStyle *platform_style,
OptionsModel *options_model, QObject *parent)
: QObject(parent), m_activity_thread(new QThread(this)),
m_activity_worker(new QObject), m_node(node),
m_platform_style(platform_style), m_options_model(options_model) {
m_handler_load_wallet = m_node.handleLoadWallet(
[this](std::unique_ptr<interfaces::Wallet> wallet) {
getOrCreateWallet(std::move(wallet));
});
for (std::unique_ptr<interfaces::Wallet> &wallet : m_node.getWallets()) {
getOrCreateWallet(std::move(wallet));
}
m_activity_worker->moveToThread(m_activity_thread);
m_activity_thread->start();
}
// Not using the default destructor because not all member types definitions are
// available in the header, just forward declared.
WalletController::~WalletController() {
m_activity_thread->quit();
m_activity_thread->wait();
delete m_activity_worker;
}
std::vector<WalletModel *> WalletController::getOpenWallets() const {
QMutexLocker locker(&m_mutex);
return m_wallets;
}
std::map<std::string, bool> WalletController::listWalletDir() const {
QMutexLocker locker(&m_mutex);
std::map<std::string, bool> wallets;
for (const std::string &name : m_node.listWalletDir()) {
wallets[name] = false;
}
for (WalletModel *wallet_model : m_wallets) {
auto it = wallets.find(wallet_model->wallet().getWalletName());
if (it != wallets.end()) {
it->second = true;
}
}
return wallets;
}
void WalletController::closeWallet(WalletModel *wallet_model, QWidget *parent) {
QMessageBox box(parent);
box.setWindowTitle(tr("Close wallet"));
box.setText(tr("Are you sure you wish to close the wallet <i>%1</i>?")
.arg(GUIUtil::HtmlEscape(wallet_model->getDisplayName())));
box.setInformativeText(
tr("Closing the wallet for too long can result in having to resync the "
"entire chain if pruning is enabled."));
box.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
box.setDefaultButton(QMessageBox::Yes);
if (box.exec() != QMessageBox::Yes) {
return;
}
// First remove wallet from node.
wallet_model->wallet().remove();
// Now release the model.
removeAndDeleteWallet(wallet_model);
}
WalletModel *WalletController::getOrCreateWallet(
std::unique_ptr<interfaces::Wallet> wallet) {
QMutexLocker locker(&m_mutex);
// Return model instance if exists.
if (!m_wallets.empty()) {
std::string name = wallet->getWalletName();
for (WalletModel *wallet_model : m_wallets) {
if (wallet_model->wallet().getWalletName() == name) {
return wallet_model;
}
}
}
// Instantiate model and register it.
WalletModel *wallet_model = new WalletModel(
std::move(wallet), m_node, m_platform_style, m_options_model, nullptr);
// Handler callback runs in a different thread so fix wallet model thread
// affinity.
wallet_model->moveToThread(thread());
wallet_model->setParent(this);
m_wallets.push_back(wallet_model);
// WalletModel::startPollBalance needs to be called in a thread managed by
// Qt because of startTimer. Considering the current thread can be a RPC
// thread, better delegate the calling to Qt with Qt::AutoConnection.
const bool called =
QMetaObject::invokeMethod(wallet_model, "startPollBalance");
assert(called);
connect(
wallet_model, &WalletModel::unload, this,
[this, wallet_model] {
// Defer removeAndDeleteWallet when no modal widget is active.
// TODO: remove this workaround by removing usage of QDiallog::exec.
if (QApplication::activeModalWidget()) {
connect(
qApp, &QApplication::focusWindowChanged, wallet_model,
[this, wallet_model]() {
if (!QApplication::activeModalWidget()) {
removeAndDeleteWallet(wallet_model);
}
},
Qt::QueuedConnection);
} else {
removeAndDeleteWallet(wallet_model);
}
},
Qt::QueuedConnection);
// Re-emit coinsSent signal from wallet model.
connect(wallet_model, &WalletModel::coinsSent, this,
&WalletController::coinsSent);
// Notify walletAdded signal on the GUI thread.
Q_EMIT walletAdded(wallet_model);
return wallet_model;
}
void WalletController::removeAndDeleteWallet(WalletModel *wallet_model) {
// Unregister wallet model.
{
QMutexLocker locker(&m_mutex);
m_wallets.erase(
std::remove(m_wallets.begin(), m_wallets.end(), wallet_model));
}
Q_EMIT walletRemoved(wallet_model);
// Currently this can trigger the unload since the model can hold the last
// CWallet shared pointer.
delete wallet_model;
}
WalletControllerActivity::WalletControllerActivity(
WalletController *wallet_controller, QWidget *parent_widget,
const CChainParams &chainparams)
: QObject(wallet_controller), m_wallet_controller(wallet_controller),
m_parent_widget(parent_widget), m_chainparams(chainparams) {}
WalletControllerActivity::~WalletControllerActivity() {
delete m_progress_dialog;
}
void WalletControllerActivity::showProgressDialog(const QString &label_text) {
m_progress_dialog = new QProgressDialog(m_parent_widget);
m_progress_dialog->setLabelText(label_text);
m_progress_dialog->setRange(0, 0);
m_progress_dialog->setCancelButton(nullptr);
m_progress_dialog->setWindowModality(Qt::ApplicationModal);
GUIUtil::PolishProgressDialog(m_progress_dialog);
}
CreateWalletActivity::CreateWalletActivity(WalletController *wallet_controller,
QWidget *parent_widget,
const CChainParams &chainparams)
: WalletControllerActivity(wallet_controller, parent_widget, chainparams) {
m_passphrase.reserve(MAX_PASSPHRASE_SIZE);
}
CreateWalletActivity::~CreateWalletActivity() {
delete m_create_wallet_dialog;
delete m_passphrase_dialog;
}
void CreateWalletActivity::askPassphrase() {
m_passphrase_dialog = new AskPassphraseDialog(
AskPassphraseDialog::Encrypt, m_parent_widget, &m_passphrase);
+ m_passphrase_dialog->setWindowModality(Qt::ApplicationModal);
m_passphrase_dialog->show();
connect(m_passphrase_dialog, &QObject::destroyed,
[this] { m_passphrase_dialog = nullptr; });
connect(m_passphrase_dialog, &QDialog::accepted,
[this] { createWallet(); });
connect(m_passphrase_dialog, &QDialog::rejected,
[this] { Q_EMIT finished(); });
}
void CreateWalletActivity::createWallet() {
showProgressDialog(
tr("Creating Wallet <b>%1</b>...")
.arg(m_create_wallet_dialog->walletName().toHtmlEscaped()));
std::string name = m_create_wallet_dialog->walletName().toStdString();
uint64_t flags = 0;
if (m_create_wallet_dialog->isDisablePrivateKeysChecked()) {
flags |= WALLET_FLAG_DISABLE_PRIVATE_KEYS;
}
if (m_create_wallet_dialog->isMakeBlankWalletChecked()) {
flags |= WALLET_FLAG_BLANK_WALLET;
}
QTimer::singleShot(500, worker(), [this, name, flags] {
std::unique_ptr<interfaces::Wallet> wallet;
WalletCreationStatus status =
node().createWallet(this->m_chainparams, m_passphrase, flags, name,
m_error_message, m_warning_message, wallet);
if (status == WalletCreationStatus::SUCCESS) {
m_wallet_model =
m_wallet_controller->getOrCreateWallet(std::move(wallet));
}
QTimer::singleShot(500, this, &CreateWalletActivity::finish);
});
}
void CreateWalletActivity::finish() {
m_progress_dialog->hide();
if (!m_error_message.original.empty()) {
QMessageBox::critical(
m_parent_widget, tr("Create wallet failed"),
QString::fromStdString(m_error_message.translated));
} else if (!m_warning_message.empty()) {
QMessageBox::warning(m_parent_widget, tr("Create wallet warning"),
QString::fromStdString(
Join(m_warning_message, "\n", OpTranslated)));
}
if (m_wallet_model) {
Q_EMIT created(m_wallet_model);
}
Q_EMIT finished();
}
void CreateWalletActivity::create() {
m_create_wallet_dialog = new CreateWalletDialog(m_parent_widget);
m_create_wallet_dialog->setWindowModality(Qt::ApplicationModal);
m_create_wallet_dialog->show();
connect(m_create_wallet_dialog, &QObject::destroyed,
[this] { m_create_wallet_dialog = nullptr; });
connect(m_create_wallet_dialog, &QDialog::rejected,
[this] { Q_EMIT finished(); });
connect(m_create_wallet_dialog, &QDialog::accepted, [this] {
if (m_create_wallet_dialog->isEncryptWalletChecked()) {
askPassphrase();
} else {
createWallet();
}
});
}
OpenWalletActivity::OpenWalletActivity(WalletController *wallet_controller,
QWidget *parent_widget,
const CChainParams &chainparams)
: WalletControllerActivity(wallet_controller, parent_widget, chainparams) {}
void OpenWalletActivity::finish() {
m_progress_dialog->hide();
if (!m_error_message.original.empty()) {
QMessageBox::critical(
m_parent_widget, tr("Open wallet failed"),
QString::fromStdString(m_error_message.translated));
} else if (!m_warning_message.empty()) {
QMessageBox::warning(m_parent_widget, tr("Open wallet warning"),
QString::fromStdString(
Join(m_warning_message, "\n", OpTranslated)));
}
if (m_wallet_model) {
Q_EMIT opened(m_wallet_model);
}
Q_EMIT finished();
}
void OpenWalletActivity::open(const std::string &path) {
QString name = path.empty() ? QString("[" + tr("default wallet") + "]")
: QString::fromStdString(path);
showProgressDialog(
tr("Opening Wallet <b>%1</b>...").arg(name.toHtmlEscaped()));
QTimer::singleShot(0, worker(), [this, path] {
std::unique_ptr<interfaces::Wallet> wallet = node().loadWallet(
this->m_chainparams, path, m_error_message, m_warning_message);
if (wallet) {
m_wallet_model =
m_wallet_controller->getOrCreateWallet(std::move(wallet));
}
QTimer::singleShot(0, this, &OpenWalletActivity::finish);
});
}