mirror of
https://github.com/dashpay/dash.git
synced 2024-12-28 13:32:47 +01:00
514 lines
20 KiB
C++
514 lines
20 KiB
C++
// Copyright (c) 2011-2014 The Bitcoin developers
|
|
// Copyright (c) 2014-2015 The Dash developers
|
|
// Distributed under the MIT/X11 software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "overviewpage.h"
|
|
#include "ui_overviewpage.h"
|
|
|
|
#include "bitcoinunits.h"
|
|
#include "clientmodel.h"
|
|
#include "darksend.h"
|
|
#include "darksendconfig.h"
|
|
#include "guiconstants.h"
|
|
#include "guiutil.h"
|
|
#include "optionsmodel.h"
|
|
#include "transactionfilterproxy.h"
|
|
#include "transactiontablemodel.h"
|
|
#include "walletmodel.h"
|
|
#include "init.h"
|
|
|
|
#include <QAbstractItemDelegate>
|
|
#include <QPainter>
|
|
#include <QSettings>
|
|
#include <QTimer>
|
|
|
|
#define DECORATION_SIZE 48
|
|
#define ICON_OFFSET 16
|
|
#define NUM_ITEMS 5
|
|
|
|
class TxViewDelegate : public QAbstractItemDelegate
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
TxViewDelegate(): QAbstractItemDelegate(), unit(BitcoinUnits::DASH)
|
|
{
|
|
|
|
}
|
|
|
|
inline void paint(QPainter *painter, const QStyleOptionViewItem &option,
|
|
const QModelIndex &index ) const
|
|
{
|
|
painter->save();
|
|
|
|
QIcon icon = qvariant_cast<QIcon>(index.data(Qt::DecorationRole));
|
|
QRect mainRect = option.rect;
|
|
mainRect.moveLeft(ICON_OFFSET);
|
|
QRect decorationRect(mainRect.topLeft(), QSize(DECORATION_SIZE, DECORATION_SIZE));
|
|
int xspace = DECORATION_SIZE + 8;
|
|
int ypad = 6;
|
|
int halfheight = (mainRect.height() - 2*ypad)/2;
|
|
QRect amountRect(mainRect.left() + xspace, mainRect.top()+ypad, mainRect.width() - xspace - ICON_OFFSET, halfheight);
|
|
QRect addressRect(mainRect.left() + xspace, mainRect.top()+ypad+halfheight, mainRect.width() - xspace, halfheight);
|
|
icon.paint(painter, decorationRect);
|
|
|
|
QDateTime date = index.data(TransactionTableModel::DateRole).toDateTime();
|
|
QString address = index.data(Qt::DisplayRole).toString();
|
|
qint64 amount = index.data(TransactionTableModel::AmountRole).toLongLong();
|
|
bool confirmed = index.data(TransactionTableModel::ConfirmedRole).toBool();
|
|
QVariant value = index.data(Qt::ForegroundRole);
|
|
QColor foreground = option.palette.color(QPalette::Text);
|
|
if(value.canConvert<QBrush>())
|
|
{
|
|
QBrush brush = qvariant_cast<QBrush>(value);
|
|
foreground = brush.color();
|
|
}
|
|
|
|
painter->setPen(foreground);
|
|
QRect boundingRect;
|
|
painter->drawText(addressRect, Qt::AlignLeft|Qt::AlignVCenter, address, &boundingRect);
|
|
|
|
if (index.data(TransactionTableModel::WatchonlyRole).toBool())
|
|
{
|
|
QIcon iconWatchonly = qvariant_cast<QIcon>(index.data(TransactionTableModel::WatchonlyDecorationRole));
|
|
QRect watchonlyRect(boundingRect.right() + 5, mainRect.top()+ypad+halfheight, 16, halfheight);
|
|
iconWatchonly.paint(painter, watchonlyRect);
|
|
}
|
|
|
|
if(amount < 0)
|
|
{
|
|
foreground = COLOR_NEGATIVE;
|
|
}
|
|
else if(!confirmed)
|
|
{
|
|
foreground = COLOR_UNCONFIRMED;
|
|
}
|
|
else
|
|
{
|
|
foreground = option.palette.color(QPalette::Text);
|
|
}
|
|
painter->setPen(foreground);
|
|
QString amountText = BitcoinUnits::formatWithUnit(unit, amount, true, BitcoinUnits::separatorAlways);
|
|
if(!confirmed)
|
|
{
|
|
amountText = QString("[") + amountText + QString("]");
|
|
}
|
|
painter->drawText(amountRect, Qt::AlignRight|Qt::AlignVCenter, amountText);
|
|
|
|
painter->setPen(option.palette.color(QPalette::Text));
|
|
painter->drawText(amountRect, Qt::AlignLeft|Qt::AlignVCenter, GUIUtil::dateTimeStr(date));
|
|
|
|
painter->restore();
|
|
}
|
|
|
|
inline QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const
|
|
{
|
|
return QSize(DECORATION_SIZE, DECORATION_SIZE);
|
|
}
|
|
|
|
int unit;
|
|
|
|
};
|
|
#include "overviewpage.moc"
|
|
|
|
OverviewPage::OverviewPage(QWidget *parent) :
|
|
QWidget(parent),
|
|
ui(new Ui::OverviewPage),
|
|
clientModel(0),
|
|
walletModel(0),
|
|
currentBalance(-1),
|
|
currentUnconfirmedBalance(-1),
|
|
currentImmatureBalance(-1),
|
|
currentWatchOnlyBalance(-1),
|
|
currentWatchUnconfBalance(-1),
|
|
currentWatchImmatureBalance(-1),
|
|
txdelegate(new TxViewDelegate()),
|
|
filter(0)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
// Recent transactions
|
|
ui->listTransactions->setItemDelegate(txdelegate);
|
|
ui->listTransactions->setIconSize(QSize(DECORATION_SIZE, DECORATION_SIZE));
|
|
ui->listTransactions->setMinimumHeight(NUM_ITEMS * (DECORATION_SIZE + 2));
|
|
ui->listTransactions->setAttribute(Qt::WA_MacShowFocusRect, false);
|
|
|
|
connect(ui->listTransactions, SIGNAL(clicked(QModelIndex)), this, SLOT(handleTransactionClicked(QModelIndex)));
|
|
|
|
|
|
// init "out of sync" warning labels
|
|
ui->labelWalletStatus->setText("(" + tr("out of sync") + ")");
|
|
ui->labelDarksendSyncStatus->setText("(" + tr("out of sync") + ")");
|
|
ui->labelTransactionsStatus->setText("(" + tr("out of sync") + ")");
|
|
|
|
if(fLiteMode){
|
|
ui->frameDarksend->setVisible(false);
|
|
} else {
|
|
if(fMasterNode){
|
|
ui->toggleDarksend->setText("(" + tr("Disabled") + ")");
|
|
ui->darksendAuto->setText("(" + tr("Disabled") + ")");
|
|
ui->darksendReset->setText("(" + tr("Disabled") + ")");
|
|
ui->frameDarksend->setEnabled(false);
|
|
} else {
|
|
if(!fEnableDarksend){
|
|
ui->toggleDarksend->setText(tr("Start Darksend Mixing"));
|
|
} else {
|
|
ui->toggleDarksend->setText(tr("Stop Darksend Mixing"));
|
|
}
|
|
timer = new QTimer(this);
|
|
connect(timer, SIGNAL(timeout()), this, SLOT(darkSendStatus()));
|
|
timer->start(333);
|
|
}
|
|
}
|
|
|
|
// start with displaying the "out of sync" warnings
|
|
showOutOfSyncWarning(true);
|
|
}
|
|
|
|
void OverviewPage::handleTransactionClicked(const QModelIndex &index)
|
|
{
|
|
if(filter)
|
|
emit transactionClicked(filter->mapToSource(index));
|
|
}
|
|
|
|
OverviewPage::~OverviewPage()
|
|
{
|
|
if(!fLiteMode && !fMasterNode) disconnect(timer, SIGNAL(timeout()), this, SLOT(darkSendStatus()));
|
|
delete ui;
|
|
}
|
|
|
|
void OverviewPage::setBalance(const CAmount& balance, const CAmount& unconfirmedBalance, const CAmount& immatureBalance, const CAmount& anonymizedBalance, const CAmount& watchOnlyBalance, const CAmount& watchUnconfBalance, const CAmount& watchImmatureBalance)
|
|
{
|
|
currentBalance = balance;
|
|
currentUnconfirmedBalance = unconfirmedBalance;
|
|
currentImmatureBalance = immatureBalance;
|
|
currentAnonymizedBalance = anonymizedBalance;
|
|
currentWatchOnlyBalance = watchOnlyBalance;
|
|
currentWatchUnconfBalance = watchUnconfBalance;
|
|
currentWatchImmatureBalance = watchImmatureBalance;
|
|
ui->labelBalance->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, balance, false, BitcoinUnits::separatorAlways));
|
|
ui->labelUnconfirmed->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, unconfirmedBalance, false, BitcoinUnits::separatorAlways));
|
|
ui->labelImmature->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, immatureBalance, false, BitcoinUnits::separatorAlways));
|
|
ui->labelAnonymized->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, anonymizedBalance, false, BitcoinUnits::separatorAlways));
|
|
ui->labelTotal->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, balance + unconfirmedBalance + immatureBalance, false, BitcoinUnits::separatorAlways));
|
|
ui->labelWatchAvailable->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, watchOnlyBalance, false, BitcoinUnits::separatorAlways));
|
|
ui->labelWatchPending->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, watchUnconfBalance, false, BitcoinUnits::separatorAlways));
|
|
ui->labelWatchImmature->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, watchImmatureBalance, false, BitcoinUnits::separatorAlways));
|
|
ui->labelWatchTotal->setText(BitcoinUnits::floorHtmlWithUnit(nDisplayUnit, watchOnlyBalance + watchUnconfBalance + watchImmatureBalance, false, BitcoinUnits::separatorAlways));
|
|
|
|
// only show immature (newly mined) balance if it's non-zero, so as not to complicate things
|
|
// for the non-mining users
|
|
bool showImmature = immatureBalance != 0;
|
|
bool showWatchOnlyImmature = watchImmatureBalance != 0;
|
|
|
|
// for symmetry reasons also show immature label when the watch-only one is shown
|
|
ui->labelImmature->setVisible(showImmature || showWatchOnlyImmature);
|
|
ui->labelImmatureText->setVisible(showImmature || showWatchOnlyImmature);
|
|
ui->labelWatchImmature->setVisible(showWatchOnlyImmature); // show watch-only immature balance
|
|
|
|
updateDarksendProgress();
|
|
|
|
static int cachedTxLocks = 0;
|
|
|
|
if(cachedTxLocks != nCompleteTXLocks){
|
|
cachedTxLocks = nCompleteTXLocks;
|
|
ui->listTransactions->update();
|
|
}
|
|
}
|
|
|
|
// show/hide watch-only labels
|
|
void OverviewPage::updateWatchOnlyLabels(bool showWatchOnly)
|
|
{
|
|
ui->labelSpendable->setVisible(showWatchOnly); // show spendable label (only when watch-only is active)
|
|
ui->labelWatchonly->setVisible(showWatchOnly); // show watch-only label
|
|
ui->lineWatchBalance->setVisible(showWatchOnly); // show watch-only balance separator line
|
|
ui->labelWatchAvailable->setVisible(showWatchOnly); // show watch-only available balance
|
|
ui->labelWatchPending->setVisible(showWatchOnly); // show watch-only pending balance
|
|
ui->labelWatchTotal->setVisible(showWatchOnly); // show watch-only total balance
|
|
|
|
if (!showWatchOnly)
|
|
ui->labelWatchImmature->hide();
|
|
}
|
|
|
|
void OverviewPage::setClientModel(ClientModel *model)
|
|
{
|
|
this->clientModel = model;
|
|
if(model)
|
|
{
|
|
// Show warning if this is a prerelease version
|
|
connect(model, SIGNAL(alertsChanged(QString)), this, SLOT(updateAlerts(QString)));
|
|
updateAlerts(model->getStatusBarWarnings());
|
|
}
|
|
}
|
|
|
|
void OverviewPage::setWalletModel(WalletModel *model)
|
|
{
|
|
this->walletModel = model;
|
|
if(model && model->getOptionsModel())
|
|
{
|
|
// Set up transaction list
|
|
filter = new TransactionFilterProxy();
|
|
filter->setSourceModel(model->getTransactionTableModel());
|
|
filter->setLimit(NUM_ITEMS);
|
|
filter->setDynamicSortFilter(true);
|
|
filter->setSortRole(Qt::EditRole);
|
|
filter->setShowInactive(false);
|
|
filter->sort(TransactionTableModel::Status, Qt::DescendingOrder);
|
|
|
|
ui->listTransactions->setModel(filter);
|
|
ui->listTransactions->setModelColumn(TransactionTableModel::ToAddress);
|
|
|
|
// Keep up to date with wallet
|
|
setBalance(model->getBalance(), model->getUnconfirmedBalance(), model->getImmatureBalance(), model->getAnonymizedBalance(),
|
|
model->getWatchBalance(), model->getWatchUnconfirmedBalance(), model->getWatchImmatureBalance());
|
|
connect(model, SIGNAL(balanceChanged(CAmount,CAmount,CAmount,CAmount,CAmount,CAmount,CAmount)), this, SLOT(setBalance(CAmount,CAmount,CAmount,CAmount,CAmount,CAmount,CAmount)));
|
|
|
|
connect(model->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));
|
|
|
|
connect(ui->darksendAuto, SIGNAL(clicked()), this, SLOT(darksendAuto()));
|
|
connect(ui->darksendReset, SIGNAL(clicked()), this, SLOT(darksendReset()));
|
|
connect(ui->toggleDarksend, SIGNAL(clicked()), this, SLOT(toggleDarksend()));
|
|
updateWatchOnlyLabels(model->haveWatchOnly());
|
|
connect(model, SIGNAL(notifyWatchonlyChanged(bool)), this, SLOT(updateWatchOnlyLabels(bool)));
|
|
}
|
|
|
|
// update the display unit, to not use the default ("DASH")
|
|
updateDisplayUnit();
|
|
}
|
|
|
|
void OverviewPage::updateDisplayUnit()
|
|
{
|
|
if(walletModel && walletModel->getOptionsModel())
|
|
{
|
|
nDisplayUnit = walletModel->getOptionsModel()->getDisplayUnit();
|
|
if(currentBalance != -1)
|
|
setBalance(currentBalance, currentUnconfirmedBalance, currentImmatureBalance, currentAnonymizedBalance,
|
|
currentWatchOnlyBalance, currentWatchUnconfBalance, currentWatchImmatureBalance);
|
|
|
|
// Update txdelegate->unit with the current unit
|
|
txdelegate->unit = nDisplayUnit;
|
|
|
|
ui->listTransactions->update();
|
|
}
|
|
}
|
|
|
|
void OverviewPage::updateAlerts(const QString &warnings)
|
|
{
|
|
this->ui->labelAlerts->setVisible(!warnings.isEmpty());
|
|
this->ui->labelAlerts->setText(warnings);
|
|
}
|
|
|
|
void OverviewPage::showOutOfSyncWarning(bool fShow)
|
|
{
|
|
ui->labelWalletStatus->setVisible(fShow);
|
|
ui->labelDarksendSyncStatus->setVisible(fShow);
|
|
ui->labelTransactionsStatus->setVisible(fShow);
|
|
}
|
|
|
|
void OverviewPage::updateDarksendProgress()
|
|
{
|
|
if(IsInitialBlockDownload() || ShutdownRequested()) return;
|
|
|
|
if(!pwalletMain) return;
|
|
|
|
int64_t nBalance = pwalletMain->GetBalance();
|
|
QString strAmountAndRounds;
|
|
QString strAnonymizeDarkcoinAmount = BitcoinUnits::formatHtmlWithUnit(nDisplayUnit, nAnonymizeDarkcoinAmount * COIN, false, BitcoinUnits::separatorAlways);
|
|
|
|
if(nBalance == 0)
|
|
{
|
|
ui->darksendProgress->setValue(0);
|
|
ui->darksendProgress->setToolTip(tr("No inputs detected"));
|
|
|
|
// when balance is zero just show info from settings
|
|
strAnonymizeDarkcoinAmount = strAnonymizeDarkcoinAmount.remove(strAnonymizeDarkcoinAmount.indexOf("."), BitcoinUnits::decimals(nDisplayUnit) + 1);
|
|
strAmountAndRounds = strAnonymizeDarkcoinAmount + " / " + tr("%n Rounds", "", nDarksendRounds);
|
|
|
|
ui->labelAmountRounds->setToolTip(tr("No inputs detected"));
|
|
ui->labelAmountRounds->setText(strAmountAndRounds);
|
|
return;
|
|
}
|
|
|
|
int64_t nDenominatedUnconfirmedBalance = pwalletMain->GetDenominatedBalance(true, true);
|
|
int64_t nMaxToAnonymize = pwalletMain->GetAnonymizableBalance(true) + nDenominatedUnconfirmedBalance;
|
|
|
|
// If it's more than the anon threshold, limit to that.
|
|
if(nMaxToAnonymize > nAnonymizeDarkcoinAmount*COIN) nMaxToAnonymize = nAnonymizeDarkcoinAmount*COIN;
|
|
|
|
if(nMaxToAnonymize == 0) return;
|
|
|
|
if(nMaxToAnonymize >= nAnonymizeDarkcoinAmount * COIN) {
|
|
ui->labelAmountRounds->setToolTip(tr("Found enough compatible inputs to anonymize %1")
|
|
.arg(strAnonymizeDarkcoinAmount));
|
|
strAnonymizeDarkcoinAmount = strAnonymizeDarkcoinAmount.remove(strAnonymizeDarkcoinAmount.indexOf("."), BitcoinUnits::decimals(nDisplayUnit) + 1);
|
|
strAmountAndRounds = strAnonymizeDarkcoinAmount + " / " + tr("%n Rounds", "", nDarksendRounds);
|
|
} else {
|
|
QString strMaxToAnonymize = BitcoinUnits::formatHtmlWithUnit(nDisplayUnit, nMaxToAnonymize, false, BitcoinUnits::separatorAlways);
|
|
ui->labelAmountRounds->setToolTip(tr("Not enough compatible inputs to anonymize <span style='color:red;'>%1</span>,<br>"
|
|
"will anonymize <span style='color:red;'>%2</span> instead")
|
|
.arg(strAnonymizeDarkcoinAmount)
|
|
.arg(strMaxToAnonymize));
|
|
strMaxToAnonymize = strMaxToAnonymize.remove(strMaxToAnonymize.indexOf("."), BitcoinUnits::decimals(nDisplayUnit) + 1);
|
|
strAmountAndRounds = "<span style='color:red;'>" +
|
|
QString(BitcoinUnits::factor(nDisplayUnit) == 1 ? "" : "~") + strMaxToAnonymize +
|
|
" / " + tr("%n Rounds", "", nDarksendRounds) + "</span>";
|
|
}
|
|
ui->labelAmountRounds->setText(strAmountAndRounds);
|
|
|
|
// calculate parts of the progress, each of them shouldn't be higher than 1
|
|
// progress of denominating
|
|
float denomPart = 0;
|
|
// mixing progress of denominated balance
|
|
float anonPart = 0;
|
|
|
|
int64_t denominatedBalance = pwalletMain->GetDenominatedBalance() + nDenominatedUnconfirmedBalance;
|
|
denomPart = (float)denominatedBalance / nMaxToAnonymize;
|
|
denomPart = denomPart > 1 ? 1 : denomPart;
|
|
|
|
anonPart = (float)pwalletMain->GetNormalizedAnonymizedBalance() / nMaxToAnonymize;
|
|
// if anonPart is > 1 then we are done, make denomPart equal 1 too
|
|
anonPart = anonPart > 1 ? (denomPart = 1, 1) : anonPart;
|
|
|
|
// apply some weights to them (sum should be <=100) and calculate the whole progress
|
|
denomPart = ceilf((denomPart * 20) * 100) / 100;
|
|
anonPart = ceilf((anonPart * 80) * 100) / 100;
|
|
float progress = denomPart + anonPart;
|
|
if(progress >= 100) progress = 100;
|
|
|
|
ui->darksendProgress->setValue(progress);
|
|
|
|
QString strToolPip = tr("Progress: %1% (%2% + %3%; denominated inputs have %4 of %n rounds on average)", "", nDarksendRounds)
|
|
.arg(progress).arg(denomPart).arg(anonPart).arg(pwalletMain->GetAverageAnonymizedRounds());
|
|
ui->darksendProgress->setToolTip(strToolPip);
|
|
}
|
|
|
|
|
|
void OverviewPage::darkSendStatus()
|
|
{
|
|
static int64_t lastNewBlock = 0;
|
|
|
|
int nBestHeight = chainActive.Tip()->nHeight;
|
|
|
|
if(nBestHeight != darkSendPool.cachedNumBlocks)
|
|
{
|
|
//we we're processing lots of blocks, we'll just leave
|
|
if(GetTime() - lastNewBlock < 10) return;
|
|
lastNewBlock = GetTime();
|
|
updateDarksendProgress();
|
|
}
|
|
|
|
if(!fEnableDarksend) {
|
|
if(nBestHeight != darkSendPool.cachedNumBlocks)
|
|
{
|
|
darkSendPool.cachedNumBlocks = nBestHeight;
|
|
|
|
ui->darksendEnabled->setText(tr("Disabled"));
|
|
ui->darksendStatus->setText("");
|
|
ui->toggleDarksend->setText(tr("Start Darksend Mixing"));
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// check darksend status and unlock if needed
|
|
if(nBestHeight != darkSendPool.cachedNumBlocks)
|
|
{
|
|
// Balance and number of transactions might have changed
|
|
darkSendPool.cachedNumBlocks = nBestHeight;
|
|
|
|
/* *******************************************************/
|
|
|
|
ui->darksendEnabled->setText(tr("Enabled"));
|
|
}
|
|
|
|
QString strStatus = QString(darkSendPool.GetStatus().c_str());
|
|
|
|
QString s = tr("Last Darksend message:\n") + strStatus;
|
|
|
|
if(s != ui->darksendStatus->text())
|
|
LogPrintf("Last Darksend message: %s\n", strStatus.toStdString());
|
|
|
|
ui->darksendStatus->setText(s);
|
|
|
|
if(darkSendPool.sessionDenom == 0){
|
|
ui->labelSubmittedDenom->setText(tr("N/A"));
|
|
} else {
|
|
std::string out;
|
|
darkSendPool.GetDenominationsToString(darkSendPool.sessionDenom, out);
|
|
QString s2(out.c_str());
|
|
ui->labelSubmittedDenom->setText(s2);
|
|
}
|
|
|
|
}
|
|
|
|
void OverviewPage::darksendAuto(){
|
|
darkSendPool.DoAutomaticDenominating();
|
|
}
|
|
|
|
void OverviewPage::darksendReset(){
|
|
darkSendPool.Reset();
|
|
|
|
QMessageBox::warning(this, tr("Darksend"),
|
|
tr("Darksend was successfully reset."),
|
|
QMessageBox::Ok, QMessageBox::Ok);
|
|
}
|
|
|
|
void OverviewPage::toggleDarksend(){
|
|
QSettings settings;
|
|
// Popup some information on first mixing
|
|
QString hasMixed = settings.value("hasMixed").toString();
|
|
if(hasMixed.isEmpty()){
|
|
QMessageBox::information(this, tr("Darksend"),
|
|
tr("If you don't want to see internal Darksend fees/transactions select \"Most Common\" as Type on the \"Transactions\" tab."),
|
|
QMessageBox::Ok, QMessageBox::Ok);
|
|
settings.setValue("hasMixed", "hasMixed");
|
|
}
|
|
if(!fEnableDarksend){
|
|
int64_t balance = pwalletMain->GetBalance();
|
|
float minAmount = 1.49 * COIN;
|
|
if(balance < minAmount){
|
|
QString strMinAmount(BitcoinUnits::formatWithUnit(nDisplayUnit, minAmount));
|
|
QMessageBox::warning(this, tr("Darksend"),
|
|
tr("Darksend requires at least %1 to use.").arg(strMinAmount),
|
|
QMessageBox::Ok, QMessageBox::Ok);
|
|
return;
|
|
}
|
|
|
|
// if wallet is locked, ask for a passphrase
|
|
if (walletModel->getEncryptionStatus() == WalletModel::Locked)
|
|
{
|
|
WalletModel::UnlockContext ctx(walletModel->requestUnlock(false));
|
|
if(!ctx.isValid())
|
|
{
|
|
//unlock was cancelled
|
|
darkSendPool.cachedNumBlocks = 0;
|
|
QMessageBox::warning(this, tr("Darksend"),
|
|
tr("Wallet is locked and user declined to unlock. Disabling Darksend."),
|
|
QMessageBox::Ok, QMessageBox::Ok);
|
|
if (fDebug) LogPrintf("Wallet is locked and user declined to unlock. Disabling Darksend.\n");
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
darkSendPool.cachedNumBlocks = 0;
|
|
fEnableDarksend = !fEnableDarksend;
|
|
|
|
if(!fEnableDarksend){
|
|
ui->toggleDarksend->setText(tr("Start Darksend Mixing"));
|
|
} else {
|
|
ui->toggleDarksend->setText(tr("Stop Darksend Mixing"));
|
|
|
|
/* show darksend configuration if client has defaults set */
|
|
|
|
if(nAnonymizeDarkcoinAmount == 0){
|
|
DarksendConfig dlg(this);
|
|
dlg.setModel(walletModel);
|
|
dlg.exec();
|
|
}
|
|
|
|
darkSendPool.DoAutomaticDenominating();
|
|
}
|
|
}
|