e8ad580f51
fb3ce75807 Don't label transactions "Open" while catching up (Hennadii Stepanov)
Pull request description:
Fix #13299.
Since the default `nSequence` is `0xFFFFFFFE` and locktime is enabled, the checking `wtx.is_final` is meaningless until the syncing has completed (ref: #1026).
This PR makes the wallet mark a transaction "Unconfirmed" instead of misleading "Open for NNN more blocks" when syncing after a period of being offline.
Before this PR (with the issue):
With this PR (the issue has been resolved):
Tree-SHA512: 358ec83b43c266a4d32a37a79dda80e80d40a2b77ad38261c84a095e613399f674aa7184805b3f6310e51ddb83ae2636b8849fcc7c4333e1b3ecbb0f70ad86d3
757 lines
26 KiB
C++
757 lines
26 KiB
C++
// Copyright (c) 2011-2018 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/transactiontablemodel.h>
|
|
|
|
#include <qt/addresstablemodel.h>
|
|
#include <qt/guiconstants.h>
|
|
#include <qt/guiutil.h>
|
|
#include <qt/optionsmodel.h>
|
|
#include <qt/platformstyle.h>
|
|
#include <qt/transactiondesc.h>
|
|
#include <qt/transactionrecord.h>
|
|
#include <qt/walletmodel.h>
|
|
|
|
#include <core_io.h>
|
|
#include <interfaces/handler.h>
|
|
#include <interfaces/node.h>
|
|
#include <sync.h>
|
|
#include <uint256.h>
|
|
#include <util/system.h>
|
|
#include <validation.h>
|
|
|
|
#include <QColor>
|
|
#include <QDateTime>
|
|
#include <QDebug>
|
|
#include <QIcon>
|
|
#include <QList>
|
|
|
|
|
|
// Amount column is right-aligned it contains numbers
|
|
static int column_alignments[] = {
|
|
Qt::AlignLeft|Qt::AlignVCenter, /* status */
|
|
Qt::AlignLeft|Qt::AlignVCenter, /* watchonly */
|
|
Qt::AlignLeft|Qt::AlignVCenter, /* date */
|
|
Qt::AlignLeft|Qt::AlignVCenter, /* type */
|
|
Qt::AlignLeft|Qt::AlignVCenter, /* address */
|
|
Qt::AlignRight|Qt::AlignVCenter /* amount */
|
|
};
|
|
|
|
// Comparison operator for sort/binary search of model tx list
|
|
struct TxLessThan
|
|
{
|
|
bool operator()(const TransactionRecord &a, const TransactionRecord &b) const
|
|
{
|
|
return a.hash < b.hash;
|
|
}
|
|
bool operator()(const TransactionRecord &a, const uint256 &b) const
|
|
{
|
|
return a.hash < b;
|
|
}
|
|
bool operator()(const uint256 &a, const TransactionRecord &b) const
|
|
{
|
|
return a < b.hash;
|
|
}
|
|
};
|
|
|
|
// Private implementation
|
|
class TransactionTablePriv
|
|
{
|
|
public:
|
|
explicit TransactionTablePriv(TransactionTableModel *_parent) :
|
|
parent(_parent)
|
|
{
|
|
}
|
|
|
|
TransactionTableModel *parent;
|
|
|
|
/* Local cache of wallet.
|
|
* As it is in the same order as the CWallet, by definition
|
|
* this is sorted by sha256.
|
|
*/
|
|
QList<TransactionRecord> cachedWallet;
|
|
|
|
/* Query entire wallet anew from core.
|
|
*/
|
|
void refreshWallet(interfaces::Wallet& wallet)
|
|
{
|
|
qDebug() << "TransactionTablePriv::refreshWallet";
|
|
cachedWallet.clear();
|
|
{
|
|
for (const auto& wtx : wallet.getWalletTxs()) {
|
|
if (TransactionRecord::showTransaction()) {
|
|
cachedWallet.append(TransactionRecord::decomposeTransaction(wtx));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Update our model of the wallet incrementally, to synchronize our model of the wallet
|
|
with that of the core.
|
|
|
|
Call with transaction that was added, removed or changed.
|
|
*/
|
|
void updateWallet(interfaces::Wallet& wallet, const uint256 &hash, int status, bool showTransaction)
|
|
{
|
|
qDebug() << "TransactionTablePriv::updateWallet: " + QString::fromStdString(hash.ToString()) + " " + QString::number(status);
|
|
|
|
// Find bounds of this transaction in model
|
|
QList<TransactionRecord>::iterator lower = qLowerBound(
|
|
cachedWallet.begin(), cachedWallet.end(), hash, TxLessThan());
|
|
QList<TransactionRecord>::iterator upper = qUpperBound(
|
|
cachedWallet.begin(), cachedWallet.end(), hash, TxLessThan());
|
|
int lowerIndex = (lower - cachedWallet.begin());
|
|
int upperIndex = (upper - cachedWallet.begin());
|
|
bool inModel = (lower != upper);
|
|
|
|
if(status == CT_UPDATED)
|
|
{
|
|
if(showTransaction && !inModel)
|
|
status = CT_NEW; /* Not in model, but want to show, treat as new */
|
|
if(!showTransaction && inModel)
|
|
status = CT_DELETED; /* In model, but want to hide, treat as deleted */
|
|
}
|
|
|
|
qDebug() << " inModel=" + QString::number(inModel) +
|
|
" Index=" + QString::number(lowerIndex) + "-" + QString::number(upperIndex) +
|
|
" showTransaction=" + QString::number(showTransaction) + " derivedStatus=" + QString::number(status);
|
|
|
|
switch(status)
|
|
{
|
|
case CT_NEW:
|
|
if(inModel)
|
|
{
|
|
qWarning() << "TransactionTablePriv::updateWallet: Warning: Got CT_NEW, but transaction is already in model";
|
|
break;
|
|
}
|
|
if(showTransaction)
|
|
{
|
|
// Find transaction in wallet
|
|
interfaces::WalletTx wtx = wallet.getWalletTx(hash);
|
|
if(!wtx.tx)
|
|
{
|
|
qWarning() << "TransactionTablePriv::updateWallet: Warning: Got CT_NEW, but transaction is not in wallet";
|
|
break;
|
|
}
|
|
// Added -- insert at the right position
|
|
QList<TransactionRecord> toInsert =
|
|
TransactionRecord::decomposeTransaction(wtx);
|
|
if(!toInsert.isEmpty()) /* only if something to insert */
|
|
{
|
|
parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex+toInsert.size()-1);
|
|
int insert_idx = lowerIndex;
|
|
for (const TransactionRecord &rec : toInsert)
|
|
{
|
|
cachedWallet.insert(insert_idx, rec);
|
|
insert_idx += 1;
|
|
}
|
|
parent->endInsertRows();
|
|
}
|
|
}
|
|
break;
|
|
case CT_DELETED:
|
|
if(!inModel)
|
|
{
|
|
qWarning() << "TransactionTablePriv::updateWallet: Warning: Got CT_DELETED, but transaction is not in model";
|
|
break;
|
|
}
|
|
// Removed -- remove entire transaction from table
|
|
parent->beginRemoveRows(QModelIndex(), lowerIndex, upperIndex-1);
|
|
cachedWallet.erase(lower, upper);
|
|
parent->endRemoveRows();
|
|
break;
|
|
case CT_UPDATED:
|
|
// Miscellaneous updates -- nothing to do, status update will take care of this, and is only computed for
|
|
// visible transactions.
|
|
for (int i = lowerIndex; i < upperIndex; i++) {
|
|
TransactionRecord *rec = &cachedWallet[i];
|
|
rec->status.needsUpdate = true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
int size()
|
|
{
|
|
return cachedWallet.size();
|
|
}
|
|
|
|
TransactionRecord *index(interfaces::Wallet& wallet, int idx)
|
|
{
|
|
if(idx >= 0 && idx < cachedWallet.size())
|
|
{
|
|
TransactionRecord *rec = &cachedWallet[idx];
|
|
|
|
// Get required locks upfront. This avoids the GUI from getting
|
|
// stuck if the core is holding the locks for a longer time - for
|
|
// example, during a wallet rescan.
|
|
//
|
|
// If a status update is needed (blocks came in since last check),
|
|
// update the status of this transaction from the wallet. Otherwise,
|
|
// simply re-use the cached status.
|
|
interfaces::WalletTxStatus wtx;
|
|
int numBlocks;
|
|
int64_t block_time;
|
|
if (wallet.tryGetTxStatus(rec->hash, wtx, numBlocks, block_time) && rec->statusUpdateNeeded(numBlocks)) {
|
|
rec->updateStatus(wtx, numBlocks, block_time);
|
|
}
|
|
return rec;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
QString describe(interfaces::Node& node, interfaces::Wallet& wallet, TransactionRecord *rec, int unit)
|
|
{
|
|
return TransactionDesc::toHTML(node, wallet, rec, unit);
|
|
}
|
|
|
|
QString getTxHex(interfaces::Wallet& wallet, TransactionRecord *rec)
|
|
{
|
|
auto tx = wallet.getTx(rec->hash);
|
|
if (tx) {
|
|
std::string strHex = EncodeHexTx(*tx);
|
|
return QString::fromStdString(strHex);
|
|
}
|
|
return QString();
|
|
}
|
|
};
|
|
|
|
TransactionTableModel::TransactionTableModel(const PlatformStyle *_platformStyle, WalletModel *parent):
|
|
QAbstractTableModel(parent),
|
|
walletModel(parent),
|
|
priv(new TransactionTablePriv(this)),
|
|
fProcessingQueuedTransactions(false),
|
|
platformStyle(_platformStyle)
|
|
{
|
|
columns << QString() << QString() << tr("Date") << tr("Type") << tr("Label") << BitcoinUnits::getAmountColumnTitle(walletModel->getOptionsModel()->getDisplayUnit());
|
|
priv->refreshWallet(walletModel->wallet());
|
|
|
|
connect(walletModel->getOptionsModel(), &OptionsModel::displayUnitChanged, this, &TransactionTableModel::updateDisplayUnit);
|
|
|
|
subscribeToCoreSignals();
|
|
}
|
|
|
|
TransactionTableModel::~TransactionTableModel()
|
|
{
|
|
unsubscribeFromCoreSignals();
|
|
delete priv;
|
|
}
|
|
|
|
/** Updates the column title to "Amount (DisplayUnit)" and emits headerDataChanged() signal for table headers to react. */
|
|
void TransactionTableModel::updateAmountColumnTitle()
|
|
{
|
|
columns[Amount] = BitcoinUnits::getAmountColumnTitle(walletModel->getOptionsModel()->getDisplayUnit());
|
|
Q_EMIT headerDataChanged(Qt::Horizontal,Amount,Amount);
|
|
}
|
|
|
|
void TransactionTableModel::updateTransaction(const QString &hash, int status, bool showTransaction)
|
|
{
|
|
uint256 updated;
|
|
updated.SetHex(hash.toStdString());
|
|
|
|
priv->updateWallet(walletModel->wallet(), updated, status, showTransaction);
|
|
}
|
|
|
|
void TransactionTableModel::updateConfirmations()
|
|
{
|
|
// Blocks came in since last poll.
|
|
// Invalidate status (number of confirmations) and (possibly) description
|
|
// for all rows. Qt is smart enough to only actually request the data for the
|
|
// visible rows.
|
|
Q_EMIT dataChanged(index(0, Status), index(priv->size()-1, Status));
|
|
Q_EMIT dataChanged(index(0, ToAddress), index(priv->size()-1, ToAddress));
|
|
}
|
|
|
|
int TransactionTableModel::rowCount(const QModelIndex &parent) const
|
|
{
|
|
Q_UNUSED(parent);
|
|
return priv->size();
|
|
}
|
|
|
|
int TransactionTableModel::columnCount(const QModelIndex &parent) const
|
|
{
|
|
Q_UNUSED(parent);
|
|
return columns.length();
|
|
}
|
|
|
|
QString TransactionTableModel::formatTxStatus(const TransactionRecord *wtx) const
|
|
{
|
|
QString status;
|
|
|
|
switch(wtx->status.status)
|
|
{
|
|
case TransactionStatus::OpenUntilBlock:
|
|
status = tr("Open for %n more block(s)","",wtx->status.open_for);
|
|
break;
|
|
case TransactionStatus::OpenUntilDate:
|
|
status = tr("Open until %1").arg(GUIUtil::dateTimeStr(wtx->status.open_for));
|
|
break;
|
|
case TransactionStatus::Unconfirmed:
|
|
status = tr("Unconfirmed");
|
|
break;
|
|
case TransactionStatus::Abandoned:
|
|
status = tr("Abandoned");
|
|
break;
|
|
case TransactionStatus::Confirming:
|
|
status = tr("Confirming (%1 of %2 recommended confirmations)").arg(wtx->status.depth).arg(TransactionRecord::RecommendedNumConfirmations);
|
|
break;
|
|
case TransactionStatus::Confirmed:
|
|
status = tr("Confirmed (%1 confirmations)").arg(wtx->status.depth);
|
|
break;
|
|
case TransactionStatus::Conflicted:
|
|
status = tr("Conflicted");
|
|
break;
|
|
case TransactionStatus::Immature:
|
|
status = tr("Immature (%1 confirmations, will be available after %2)").arg(wtx->status.depth).arg(wtx->status.depth + wtx->status.matures_in);
|
|
break;
|
|
case TransactionStatus::NotAccepted:
|
|
status = tr("Generated but not accepted");
|
|
break;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
QString TransactionTableModel::formatTxDate(const TransactionRecord *wtx) const
|
|
{
|
|
if(wtx->time)
|
|
{
|
|
return GUIUtil::dateTimeStr(wtx->time);
|
|
}
|
|
return QString();
|
|
}
|
|
|
|
/* Look up address in address book, if found return label (address)
|
|
otherwise just return (address)
|
|
*/
|
|
QString TransactionTableModel::lookupAddress(const std::string &address, bool tooltip) const
|
|
{
|
|
QString label = walletModel->getAddressTableModel()->labelForAddress(QString::fromStdString(address));
|
|
QString description;
|
|
if(!label.isEmpty())
|
|
{
|
|
description += label;
|
|
}
|
|
if(label.isEmpty() || tooltip)
|
|
{
|
|
description += QString(" (") + QString::fromStdString(address) + QString(")");
|
|
}
|
|
return description;
|
|
}
|
|
|
|
QString TransactionTableModel::formatTxType(const TransactionRecord *wtx) const
|
|
{
|
|
switch(wtx->type)
|
|
{
|
|
case TransactionRecord::RecvWithAddress:
|
|
return tr("Received with");
|
|
case TransactionRecord::RecvFromOther:
|
|
return tr("Received from");
|
|
case TransactionRecord::SendToAddress:
|
|
case TransactionRecord::SendToOther:
|
|
return tr("Sent to");
|
|
case TransactionRecord::SendToSelf:
|
|
return tr("Payment to yourself");
|
|
case TransactionRecord::Generated:
|
|
return tr("Mined");
|
|
default:
|
|
return QString();
|
|
}
|
|
}
|
|
|
|
QVariant TransactionTableModel::txAddressDecoration(const TransactionRecord *wtx) const
|
|
{
|
|
switch(wtx->type)
|
|
{
|
|
case TransactionRecord::Generated:
|
|
return QIcon(":/icons/tx_mined");
|
|
case TransactionRecord::RecvWithAddress:
|
|
case TransactionRecord::RecvFromOther:
|
|
return QIcon(":/icons/tx_input");
|
|
case TransactionRecord::SendToAddress:
|
|
case TransactionRecord::SendToOther:
|
|
return QIcon(":/icons/tx_output");
|
|
default:
|
|
return QIcon(":/icons/tx_inout");
|
|
}
|
|
}
|
|
|
|
QString TransactionTableModel::formatTxToAddress(const TransactionRecord *wtx, bool tooltip) const
|
|
{
|
|
QString watchAddress;
|
|
if (tooltip) {
|
|
// Mark transactions involving watch-only addresses by adding " (watch-only)"
|
|
watchAddress = wtx->involvesWatchAddress ? QString(" (") + tr("watch-only") + QString(")") : "";
|
|
}
|
|
|
|
switch(wtx->type)
|
|
{
|
|
case TransactionRecord::RecvFromOther:
|
|
return QString::fromStdString(wtx->address) + watchAddress;
|
|
case TransactionRecord::RecvWithAddress:
|
|
case TransactionRecord::SendToAddress:
|
|
case TransactionRecord::Generated:
|
|
return lookupAddress(wtx->address, tooltip) + watchAddress;
|
|
case TransactionRecord::SendToOther:
|
|
return QString::fromStdString(wtx->address) + watchAddress;
|
|
case TransactionRecord::SendToSelf:
|
|
default:
|
|
return tr("(n/a)") + watchAddress;
|
|
}
|
|
}
|
|
|
|
QVariant TransactionTableModel::addressColor(const TransactionRecord *wtx) const
|
|
{
|
|
// Show addresses without label in a less visible color
|
|
switch(wtx->type)
|
|
{
|
|
case TransactionRecord::RecvWithAddress:
|
|
case TransactionRecord::SendToAddress:
|
|
case TransactionRecord::Generated:
|
|
{
|
|
QString label = walletModel->getAddressTableModel()->labelForAddress(QString::fromStdString(wtx->address));
|
|
if(label.isEmpty())
|
|
return COLOR_BAREADDRESS;
|
|
} break;
|
|
case TransactionRecord::SendToSelf:
|
|
return COLOR_BAREADDRESS;
|
|
default:
|
|
break;
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
QString TransactionTableModel::formatTxAmount(const TransactionRecord *wtx, bool showUnconfirmed, BitcoinUnits::SeparatorStyle separators) const
|
|
{
|
|
QString str = BitcoinUnits::format(walletModel->getOptionsModel()->getDisplayUnit(), wtx->credit + wtx->debit, false, separators);
|
|
if(showUnconfirmed)
|
|
{
|
|
if(!wtx->status.countsForBalance)
|
|
{
|
|
str = QString("[") + str + QString("]");
|
|
}
|
|
}
|
|
return QString(str);
|
|
}
|
|
|
|
QVariant TransactionTableModel::txStatusDecoration(const TransactionRecord *wtx) const
|
|
{
|
|
switch(wtx->status.status)
|
|
{
|
|
case TransactionStatus::OpenUntilBlock:
|
|
case TransactionStatus::OpenUntilDate:
|
|
return COLOR_TX_STATUS_OPENUNTILDATE;
|
|
case TransactionStatus::Unconfirmed:
|
|
return QIcon(":/icons/transaction_0");
|
|
case TransactionStatus::Abandoned:
|
|
return QIcon(":/icons/transaction_abandoned");
|
|
case TransactionStatus::Confirming:
|
|
switch(wtx->status.depth)
|
|
{
|
|
case 1: return QIcon(":/icons/transaction_1");
|
|
case 2: return QIcon(":/icons/transaction_2");
|
|
case 3: return QIcon(":/icons/transaction_3");
|
|
case 4: return QIcon(":/icons/transaction_4");
|
|
default: return QIcon(":/icons/transaction_5");
|
|
};
|
|
case TransactionStatus::Confirmed:
|
|
return QIcon(":/icons/transaction_confirmed");
|
|
case TransactionStatus::Conflicted:
|
|
return QIcon(":/icons/transaction_conflicted");
|
|
case TransactionStatus::Immature: {
|
|
int total = wtx->status.depth + wtx->status.matures_in;
|
|
int part = (wtx->status.depth * 4 / total) + 1;
|
|
return QIcon(QString(":/icons/transaction_%1").arg(part));
|
|
}
|
|
case TransactionStatus::NotAccepted:
|
|
return QIcon(":/icons/transaction_0");
|
|
default:
|
|
return COLOR_BLACK;
|
|
}
|
|
}
|
|
|
|
QVariant TransactionTableModel::txWatchonlyDecoration(const TransactionRecord *wtx) const
|
|
{
|
|
if (wtx->involvesWatchAddress)
|
|
return QIcon(":/icons/eye");
|
|
else
|
|
return QVariant();
|
|
}
|
|
|
|
QString TransactionTableModel::formatTooltip(const TransactionRecord *rec) const
|
|
{
|
|
QString tooltip = formatTxStatus(rec) + QString("\n") + formatTxType(rec);
|
|
if(rec->type==TransactionRecord::RecvFromOther || rec->type==TransactionRecord::SendToOther ||
|
|
rec->type==TransactionRecord::SendToAddress || rec->type==TransactionRecord::RecvWithAddress)
|
|
{
|
|
tooltip += QString(" ") + formatTxToAddress(rec, true);
|
|
}
|
|
return tooltip;
|
|
}
|
|
|
|
QVariant TransactionTableModel::data(const QModelIndex &index, int role) const
|
|
{
|
|
if(!index.isValid())
|
|
return QVariant();
|
|
TransactionRecord *rec = static_cast<TransactionRecord*>(index.internalPointer());
|
|
|
|
switch(role)
|
|
{
|
|
case RawDecorationRole:
|
|
switch(index.column())
|
|
{
|
|
case Status:
|
|
return txStatusDecoration(rec);
|
|
case Watchonly:
|
|
return txWatchonlyDecoration(rec);
|
|
case ToAddress:
|
|
return txAddressDecoration(rec);
|
|
}
|
|
break;
|
|
case Qt::DecorationRole:
|
|
{
|
|
QIcon icon = qvariant_cast<QIcon>(index.data(RawDecorationRole));
|
|
return platformStyle->TextColorIcon(icon);
|
|
}
|
|
case Qt::DisplayRole:
|
|
switch(index.column())
|
|
{
|
|
case Date:
|
|
return formatTxDate(rec);
|
|
case Type:
|
|
return formatTxType(rec);
|
|
case ToAddress:
|
|
return formatTxToAddress(rec, false);
|
|
case Amount:
|
|
return formatTxAmount(rec, true, BitcoinUnits::separatorAlways);
|
|
}
|
|
break;
|
|
case Qt::EditRole:
|
|
// Edit role is used for sorting, so return the unformatted values
|
|
switch(index.column())
|
|
{
|
|
case Status:
|
|
return QString::fromStdString(rec->status.sortKey);
|
|
case Date:
|
|
return rec->time;
|
|
case Type:
|
|
return formatTxType(rec);
|
|
case Watchonly:
|
|
return (rec->involvesWatchAddress ? 1 : 0);
|
|
case ToAddress:
|
|
return formatTxToAddress(rec, true);
|
|
case Amount:
|
|
return qint64(rec->credit + rec->debit);
|
|
}
|
|
break;
|
|
case Qt::ToolTipRole:
|
|
return formatTooltip(rec);
|
|
case Qt::TextAlignmentRole:
|
|
return column_alignments[index.column()];
|
|
case Qt::ForegroundRole:
|
|
// Use the "danger" color for abandoned transactions
|
|
if(rec->status.status == TransactionStatus::Abandoned)
|
|
{
|
|
return COLOR_TX_STATUS_DANGER;
|
|
}
|
|
// Non-confirmed (but not immature) as transactions are grey
|
|
if(!rec->status.countsForBalance && rec->status.status != TransactionStatus::Immature)
|
|
{
|
|
return COLOR_UNCONFIRMED;
|
|
}
|
|
if(index.column() == Amount && (rec->credit+rec->debit) < 0)
|
|
{
|
|
return COLOR_NEGATIVE;
|
|
}
|
|
if(index.column() == ToAddress)
|
|
{
|
|
return addressColor(rec);
|
|
}
|
|
break;
|
|
case TypeRole:
|
|
return rec->type;
|
|
case DateRole:
|
|
return QDateTime::fromTime_t(static_cast<uint>(rec->time));
|
|
case WatchonlyRole:
|
|
return rec->involvesWatchAddress;
|
|
case WatchonlyDecorationRole:
|
|
return txWatchonlyDecoration(rec);
|
|
case LongDescriptionRole:
|
|
return priv->describe(walletModel->node(), walletModel->wallet(), rec, walletModel->getOptionsModel()->getDisplayUnit());
|
|
case AddressRole:
|
|
return QString::fromStdString(rec->address);
|
|
case LabelRole:
|
|
return walletModel->getAddressTableModel()->labelForAddress(QString::fromStdString(rec->address));
|
|
case AmountRole:
|
|
return qint64(rec->credit + rec->debit);
|
|
case TxHashRole:
|
|
return rec->getTxHash();
|
|
case TxHexRole:
|
|
return priv->getTxHex(walletModel->wallet(), rec);
|
|
case TxPlainTextRole:
|
|
{
|
|
QString details;
|
|
QDateTime date = QDateTime::fromTime_t(static_cast<uint>(rec->time));
|
|
QString txLabel = walletModel->getAddressTableModel()->labelForAddress(QString::fromStdString(rec->address));
|
|
|
|
details.append(date.toString("M/d/yy HH:mm"));
|
|
details.append(" ");
|
|
details.append(formatTxStatus(rec));
|
|
details.append(". ");
|
|
if(!formatTxType(rec).isEmpty()) {
|
|
details.append(formatTxType(rec));
|
|
details.append(" ");
|
|
}
|
|
if(!rec->address.empty()) {
|
|
if(txLabel.isEmpty())
|
|
details.append(tr("(no label)") + " ");
|
|
else {
|
|
details.append("(");
|
|
details.append(txLabel);
|
|
details.append(") ");
|
|
}
|
|
details.append(QString::fromStdString(rec->address));
|
|
details.append(" ");
|
|
}
|
|
details.append(formatTxAmount(rec, false, BitcoinUnits::separatorNever));
|
|
return details;
|
|
}
|
|
case ConfirmedRole:
|
|
return rec->status.countsForBalance;
|
|
case FormattedAmountRole:
|
|
// Used for copy/export, so don't include separators
|
|
return formatTxAmount(rec, false, BitcoinUnits::separatorNever);
|
|
case StatusRole:
|
|
return rec->status.status;
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
QVariant TransactionTableModel::headerData(int section, Qt::Orientation orientation, int role) const
|
|
{
|
|
if(orientation == Qt::Horizontal)
|
|
{
|
|
if(role == Qt::DisplayRole)
|
|
{
|
|
return columns[section];
|
|
}
|
|
else if (role == Qt::TextAlignmentRole)
|
|
{
|
|
return column_alignments[section];
|
|
} else if (role == Qt::ToolTipRole)
|
|
{
|
|
switch(section)
|
|
{
|
|
case Status:
|
|
return tr("Transaction status. Hover over this field to show number of confirmations.");
|
|
case Date:
|
|
return tr("Date and time that the transaction was received.");
|
|
case Type:
|
|
return tr("Type of transaction.");
|
|
case Watchonly:
|
|
return tr("Whether or not a watch-only address is involved in this transaction.");
|
|
case ToAddress:
|
|
return tr("User-defined intent/purpose of the transaction.");
|
|
case Amount:
|
|
return tr("Amount removed from or added to balance.");
|
|
}
|
|
}
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
QModelIndex TransactionTableModel::index(int row, int column, const QModelIndex &parent) const
|
|
{
|
|
Q_UNUSED(parent);
|
|
TransactionRecord *data = priv->index(walletModel->wallet(), row);
|
|
if(data)
|
|
{
|
|
return createIndex(row, column, priv->index(walletModel->wallet(), row));
|
|
}
|
|
return QModelIndex();
|
|
}
|
|
|
|
void TransactionTableModel::updateDisplayUnit()
|
|
{
|
|
// emit dataChanged to update Amount column with the current unit
|
|
updateAmountColumnTitle();
|
|
Q_EMIT dataChanged(index(0, Amount), index(priv->size()-1, Amount));
|
|
}
|
|
|
|
// queue notifications to show a non freezing progress dialog e.g. for rescan
|
|
struct TransactionNotification
|
|
{
|
|
public:
|
|
TransactionNotification() {}
|
|
TransactionNotification(uint256 _hash, ChangeType _status, bool _showTransaction):
|
|
hash(_hash), status(_status), showTransaction(_showTransaction) {}
|
|
|
|
void invoke(QObject *ttm)
|
|
{
|
|
QString strHash = QString::fromStdString(hash.GetHex());
|
|
qDebug() << "NotifyTransactionChanged: " + strHash + " status= " + QString::number(status);
|
|
QMetaObject::invokeMethod(ttm, "updateTransaction", Qt::QueuedConnection,
|
|
Q_ARG(QString, strHash),
|
|
Q_ARG(int, status),
|
|
Q_ARG(bool, showTransaction));
|
|
}
|
|
private:
|
|
uint256 hash;
|
|
ChangeType status;
|
|
bool showTransaction;
|
|
};
|
|
|
|
static bool fQueueNotifications = false;
|
|
static std::vector< TransactionNotification > vQueueNotifications;
|
|
|
|
static void NotifyTransactionChanged(TransactionTableModel *ttm, const uint256 &hash, ChangeType status)
|
|
{
|
|
// Find transaction in wallet
|
|
// Determine whether to show transaction or not (determine this here so that no relocking is needed in GUI thread)
|
|
bool showTransaction = TransactionRecord::showTransaction();
|
|
|
|
TransactionNotification notification(hash, status, showTransaction);
|
|
|
|
if (fQueueNotifications)
|
|
{
|
|
vQueueNotifications.push_back(notification);
|
|
return;
|
|
}
|
|
notification.invoke(ttm);
|
|
}
|
|
|
|
static void ShowProgress(TransactionTableModel *ttm, const std::string &title, int nProgress)
|
|
{
|
|
if (nProgress == 0)
|
|
fQueueNotifications = true;
|
|
|
|
if (nProgress == 100)
|
|
{
|
|
fQueueNotifications = false;
|
|
if (vQueueNotifications.size() > 10) // prevent balloon spam, show maximum 10 balloons
|
|
QMetaObject::invokeMethod(ttm, "setProcessingQueuedTransactions", Qt::QueuedConnection, Q_ARG(bool, true));
|
|
for (unsigned int i = 0; i < vQueueNotifications.size(); ++i)
|
|
{
|
|
if (vQueueNotifications.size() - i <= 10)
|
|
QMetaObject::invokeMethod(ttm, "setProcessingQueuedTransactions", Qt::QueuedConnection, Q_ARG(bool, false));
|
|
|
|
vQueueNotifications[i].invoke(ttm);
|
|
}
|
|
std::vector<TransactionNotification >().swap(vQueueNotifications); // clear
|
|
}
|
|
}
|
|
|
|
void TransactionTableModel::subscribeToCoreSignals()
|
|
{
|
|
// Connect signals to wallet
|
|
m_handler_transaction_changed = walletModel->wallet().handleTransactionChanged(std::bind(NotifyTransactionChanged, this, std::placeholders::_1, std::placeholders::_2));
|
|
m_handler_show_progress = walletModel->wallet().handleShowProgress(std::bind(ShowProgress, this, std::placeholders::_1, std::placeholders::_2));
|
|
}
|
|
|
|
void TransactionTableModel::unsubscribeFromCoreSignals()
|
|
{
|
|
// Disconnect signals from wallet
|
|
m_handler_transaction_changed->disconnect();
|
|
m_handler_show_progress->disconnect();
|
|
}
|