lbrycrd/src/qt/transactiontablemodel.cpp

734 lines
25 KiB
C++
Raw Normal View History

// Copyright (c) 2011-2014 The Bitcoin Core developers
2014-12-13 05:09:33 +01:00
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
2011-05-12 14:49:42 +02:00
#include "transactiontablemodel.h"
#include "addresstablemodel.h"
2011-05-28 20:32:19 +02:00
#include "guiconstants.h"
#include "guiutil.h"
#include "optionsmodel.h"
2014-11-06 20:55:52 +01:00
#include "scicon.h"
#include "transactiondesc.h"
#include "transactionrecord.h"
#include "walletmodel.h"
2011-05-08 16:30:10 +02:00
#include "main.h"
#include "sync.h"
#include "uint256.h"
#include "util.h"
2012-04-15 22:10:54 +02:00
#include "wallet.h"
#include <QColor>
#include <QDateTime>
#include <QDebug>
#include <QIcon>
#include <QList>
2011-05-10 19:03:10 +02:00
// 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
2011-06-03 20:48:03 +02:00
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
2011-05-27 08:20:23 +02:00
{
public:
TransactionTablePriv(CWallet *wallet, TransactionTableModel *parent) :
wallet(wallet),
parent(parent)
2011-06-03 20:48:03 +02:00
{
}
CWallet *wallet;
2011-06-03 20:48:03 +02:00
TransactionTableModel *parent;
2011-05-28 20:32:19 +02:00
/* Local cache of wallet.
* As it is in the same order as the CWallet, by definition
* this is sorted by sha256.
*/
2011-05-27 08:20:23 +02:00
QList<TransactionRecord> cachedWallet;
/* Query entire wallet anew from core.
*/
2011-05-28 20:32:19 +02:00
void refreshWallet()
2011-05-27 08:20:23 +02:00
{
qDebug() << "TransactionTablePriv::refreshWallet";
cachedWallet.clear();
2011-05-27 08:20:23 +02:00
{
LOCK2(cs_main, wallet->cs_wallet);
for(std::map<uint256, CWalletTx>::iterator it = wallet->mapWallet.begin(); it != wallet->mapWallet.end(); ++it)
2011-05-27 08:20:23 +02:00
{
if(TransactionRecord::showTransaction(it->second))
cachedWallet.append(TransactionRecord::decomposeTransaction(wallet, it->second));
2011-05-27 08:20:23 +02:00
}
}
}
/* 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.
2011-05-28 20:32:19 +02:00
*/
void updateWallet(const uint256 &hash, int status, bool showTransaction)
2011-05-28 20:32:19 +02:00
{
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)
2011-06-03 20:48:03 +02:00
{
qWarning() << "TransactionTablePriv::updateWallet: Warning: Got CT_NEW, but transaction is already in model";
break;
}
if(showTransaction)
{
LOCK2(cs_main, wallet->cs_wallet);
// Find transaction in wallet
std::map<uint256, CWalletTx>::iterator mi = wallet->mapWallet.find(hash);
if(mi == wallet->mapWallet.end())
{
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(wallet, mi->second);
if(!toInsert.isEmpty()) /* only if something to insert */
2011-06-03 20:48:03 +02:00
{
parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex+toInsert.size()-1);
int insert_idx = lowerIndex;
foreach(const TransactionRecord &rec, toInsert)
2011-06-03 20:48:03 +02:00
{
cachedWallet.insert(insert_idx, rec);
insert_idx += 1;
2011-06-03 20:48:03 +02:00
}
parent->endInsertRows();
2011-06-07 18:59:01 +02:00
}
}
break;
case CT_DELETED:
if(!inModel)
{
qWarning() << "TransactionTablePriv::updateWallet: Warning: Got CT_DELETED, but transaction is not in model";
break;
2011-06-03 20:48:03 +02:00
}
// 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.
break;
2011-05-28 20:32:19 +02:00
}
}
2011-05-27 08:20:23 +02:00
int size()
{
return cachedWallet.size();
}
TransactionRecord *index(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.
TRY_LOCK(cs_main, lockMain);
if(lockMain)
{
TRY_LOCK(wallet->cs_wallet, lockWallet);
if(lockWallet && rec->statusUpdateNeeded())
{
std::map<uint256, CWalletTx>::iterator mi = wallet->mapWallet.find(rec->hash);
if(mi != wallet->mapWallet.end())
{
rec->updateStatus(mi->second);
}
}
}
return rec;
2011-06-07 18:59:01 +02:00
}
return 0;
2011-05-27 08:20:23 +02:00
}
2011-05-28 20:32:19 +02:00
QString describe(TransactionRecord *rec, int unit)
{
{
LOCK2(cs_main, wallet->cs_wallet);
std::map<uint256, CWalletTx>::iterator mi = wallet->mapWallet.find(rec->hash);
if(mi != wallet->mapWallet.end())
{
return TransactionDesc::toHTML(wallet, mi->second, rec, unit);
}
}
return QString();
}
2011-05-27 08:20:23 +02:00
};
TransactionTableModel::TransactionTableModel(CWallet* wallet, WalletModel *parent):
2011-05-27 08:20:23 +02:00
QAbstractTableModel(parent),
wallet(wallet),
walletModel(parent),
priv(new TransactionTablePriv(wallet, this)),
fProcessingQueuedTransactions(false)
2011-05-08 16:30:10 +02:00
{
columns << QString() << QString() << tr("Date") << tr("Type") << tr("Address") << BitcoinUnits::getAmountColumnTitle(walletModel->getOptionsModel()->getDisplayUnit());
2011-06-01 15:33:33 +02:00
priv->refreshWallet();
2011-05-28 20:32:19 +02:00
connect(walletModel->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));
subscribeToCoreSignals();
2011-05-27 08:20:23 +02:00
}
TransactionTableModel::~TransactionTableModel()
{
unsubscribeFromCoreSignals();
2011-06-01 15:33:33 +02:00
delete priv;
2011-05-08 16:30:10 +02:00
}
/** 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());
emit headerDataChanged(Qt::Horizontal,Amount,Amount);
}
void TransactionTableModel::updateTransaction(const QString &hash, int status, bool showTransaction)
{
uint256 updated;
updated.SetHex(hash.toStdString());
2011-05-28 20:32:19 +02:00
priv->updateWallet(updated, status, showTransaction);
}
2011-05-28 20:32:19 +02:00
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.
emit dataChanged(index(0, Status), index(priv->size()-1, Status));
emit dataChanged(index(0, ToAddress), index(priv->size()-1, ToAddress));
}
2011-05-27 08:20:23 +02:00
2011-05-08 16:30:10 +02:00
int TransactionTableModel::rowCount(const QModelIndex &parent) const
{
Q_UNUSED(parent);
2011-06-01 15:33:33 +02:00
return priv->size();
2011-05-08 16:30:10 +02:00
}
int TransactionTableModel::columnCount(const QModelIndex &parent) const
{
Q_UNUSED(parent);
return columns.length();
}
2011-08-05 15:35:52 +02:00
QString TransactionTableModel::formatTxStatus(const TransactionRecord *wtx) const
2011-05-27 08:20:23 +02:00
{
2011-05-27 18:38:30 +02:00
QString status;
2011-05-27 20:36:58 +02:00
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::Offline:
status = tr("Offline");
break;
case TransactionStatus::Unconfirmed:
status = tr("Unconfirmed");
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::MaturesWarning:
status = tr("This block was not received by any other nodes and will probably not be accepted!");
break;
case TransactionStatus::NotAccepted:
status = tr("Generated but not accepted");
break;
}
2011-05-27 18:38:30 +02:00
2011-08-05 15:35:52 +02:00
return status;
2011-05-27 08:20:23 +02:00
}
2011-08-05 15:35:52 +02:00
QString TransactionTableModel::formatTxDate(const TransactionRecord *wtx) const
2011-05-27 08:20:23 +02:00
{
2011-05-27 18:38:30 +02:00
if(wtx->time)
{
return GUIUtil::dateTimeStr(wtx->time);
2011-06-07 18:59:01 +02:00
}
return QString();
2011-05-27 08:20:23 +02:00
}
/* 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(")");
}
2011-05-27 20:36:58 +02:00
return description;
}
2011-07-31 17:05:34 +02:00
QString TransactionTableModel::formatTxType(const TransactionRecord *wtx) const
2011-05-27 08:20:23 +02:00
{
switch(wtx->type)
{
case TransactionRecord::RecvWithAddress:
2011-07-31 17:05:34 +02:00
return tr("Received with");
case TransactionRecord::RecvFromOther:
return tr("Received from");
case TransactionRecord::SendToAddress:
case TransactionRecord::SendToOther:
2011-07-31 17:05:34 +02:00
return tr("Sent to");
case TransactionRecord::SendToSelf:
2011-07-31 17:05:34 +02:00
return tr("Payment to yourself");
case TransactionRecord::Generated:
2011-07-31 17:05:34 +02:00
return tr("Mined");
default:
return QString();
}
}
2011-07-31 17:05:34 +02:00
QVariant TransactionTableModel::txAddressDecoration(const TransactionRecord *wtx) const
{
2011-07-31 17:05:34 +02:00
switch(wtx->type)
{
case TransactionRecord::Generated:
return QIcon(":/icons/tx_mined");
case TransactionRecord::RecvWithAddress:
case TransactionRecord::RecvFromOther:
2011-07-31 17:05:34 +02:00
return QIcon(":/icons/tx_input");
case TransactionRecord::SendToAddress:
case TransactionRecord::SendToOther:
2011-07-31 17:05:34 +02:00
return QIcon(":/icons/tx_output");
default:
return QIcon(":/icons/tx_inout");
}
}
2011-07-31 17:05:34 +02:00
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:
2011-07-31 17:05:34 +02:00
default:
return tr("(n/a)") + watchAddress;
}
2011-05-27 08:20:23 +02:00
}
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
2011-05-27 08:20:23 +02:00
{
QString str = BitcoinUnits::format(walletModel->getOptionsModel()->getDisplayUnit(), wtx->credit + wtx->debit, false, separators);
if(showUnconfirmed)
2011-05-27 18:38:30 +02:00
{
if(!wtx->status.countsForBalance)
{
str = QString("[") + str + QString("]");
}
2011-05-27 18:38:30 +02:00
}
2011-08-05 15:35:52 +02:00
return QString(str);
2011-05-27 08:20:23 +02:00
}
2011-08-05 15:35:52 +02:00
QVariant TransactionTableModel::txStatusDecoration(const TransactionRecord *wtx) const
2011-06-13 09:05:48 +02:00
{
switch(wtx->status.status)
{
case TransactionStatus::OpenUntilBlock:
case TransactionStatus::OpenUntilDate:
return COLOR_TX_STATUS_OPENUNTILDATE;
case TransactionStatus::Offline:
return COLOR_TX_STATUS_OFFLINE;
case TransactionStatus::Unconfirmed:
return QIcon(":/icons/transaction_0");
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::MaturesWarning:
case TransactionStatus::NotAccepted:
return QIcon(":/icons/transaction_0");
default:
return COLOR_BLACK;
2011-06-13 09:05:48 +02:00
}
}
QVariant TransactionTableModel::txWatchonlyDecoration(const TransactionRecord *wtx) const
{
if (wtx->involvesWatchAddress)
return QIcon(":/icons/eye");
else
return QVariant();
}
2011-08-05 15:35:52 +02:00
QString TransactionTableModel::formatTooltip(const TransactionRecord *rec) const
{
QString tooltip = formatTxStatus(rec) + QString("\n") + formatTxType(rec);
if(rec->type==TransactionRecord::RecvFromOther || rec->type==TransactionRecord::SendToOther ||
2011-08-05 15:35:52 +02:00
rec->type==TransactionRecord::SendToAddress || rec->type==TransactionRecord::RecvWithAddress)
{
tooltip += QString(" ") + formatTxToAddress(rec, true);
}
return tooltip;
}
2011-05-08 16:30:10 +02:00
QVariant TransactionTableModel::data(const QModelIndex &index, int role) const
{
if(!index.isValid())
return QVariant();
2011-05-27 08:20:23 +02:00
TransactionRecord *rec = static_cast<TransactionRecord*>(index.internalPointer());
2011-05-08 16:30:10 +02:00
switch(role)
2011-06-13 09:05:48 +02:00
{
2014-11-06 20:55:52 +01:00
case RawDecorationRole:
2011-07-31 17:05:34 +02:00
switch(index.column())
2011-06-13 09:05:48 +02:00
{
2011-07-31 17:05:34 +02:00
case Status:
2011-08-05 15:35:52 +02:00
return txStatusDecoration(rec);
case Watchonly:
return txWatchonlyDecoration(rec);
2011-07-31 17:05:34 +02:00
case ToAddress:
return txAddressDecoration(rec);
2011-06-13 09:05:48 +02:00
}
break;
2014-11-06 20:55:52 +01:00
case Qt::DecorationRole:
{
QIcon icon = qvariant_cast<QIcon>(index.data(RawDecorationRole));
return TextColorIcon(icon);
}
case Qt::DisplayRole:
2011-05-27 08:20:23 +02:00
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);
2011-05-27 08:20:23 +02:00
}
break;
case Qt::EditRole:
// Edit role is used for sorting, so return the unformatted values
2011-05-28 20:32:19 +02:00
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:
2014-04-23 00:46:19 +02:00
return qint64(rec->credit + rec->debit);
2011-05-28 20:32:19 +02:00
}
break;
case Qt::ToolTipRole:
return formatTooltip(rec);
case Qt::TextAlignmentRole:
2011-05-08 22:23:31 +02:00
return column_alignments[index.column()];
case Qt::ForegroundRole:
// Non-confirmed (but not immature) as transactions are grey
if(!rec->status.countsForBalance && rec->status.status != TransactionStatus::Immature)
2011-06-07 18:59:01 +02:00
{
2011-07-25 18:39:52 +02:00
return COLOR_UNCONFIRMED;
}
if(index.column() == Amount && (rec->credit+rec->debit) < 0)
{
2011-07-25 18:39:52 +02:00
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(rec, walletModel->getOptionsModel()->getDisplayUnit());
case AddressRole:
return QString::fromStdString(rec->address);
case LabelRole:
return walletModel->getAddressTableModel()->labelForAddress(QString::fromStdString(rec->address));
case AmountRole:
2014-04-23 00:46:19 +02:00
return qint64(rec->credit + rec->debit);
case TxIDRole:
return rec->getTxID();
case TxHashRole:
return QString::fromStdString(rec->hash.ToString());
case ConfirmedRole:
return rec->status.countsForBalance;
case FormattedAmountRole:
2014-07-25 17:43:41 +02:00
// Used for copy/export, so don't include separators
return formatTxAmount(rec, false, BitcoinUnits::separatorNever);
case StatusRole:
return rec->status.status;
}
2011-05-08 16:30:10 +02:00
return QVariant();
}
QVariant TransactionTableModel::headerData(int section, Qt::Orientation orientation, int role) const
{
2011-05-28 16:09:23 +02:00
if(orientation == Qt::Horizontal)
2011-05-08 22:23:31 +02:00
{
2011-05-28 16:09:23 +02:00
if(role == Qt::DisplayRole)
2011-05-08 22:23:31 +02:00
{
return columns[section];
2011-06-07 18:59:01 +02:00
}
else if (role == Qt::TextAlignmentRole)
2011-05-28 16:09:23 +02:00
{
return column_alignments[section];
} else if (role == Qt::ToolTipRole)
{
switch(section)
{
case Status:
2011-06-24 21:45:33 +02:00
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("Destination address of transaction.");
case Amount:
return tr("Amount removed from or added to balance.");
}
2011-05-08 22:23:31 +02:00
}
2011-05-08 16:30:10 +02:00
}
return QVariant();
}
2011-06-01 15:33:33 +02:00
QModelIndex TransactionTableModel::index(int row, int column, const QModelIndex &parent) const
2011-05-27 08:20:23 +02:00
{
Q_UNUSED(parent);
2011-06-01 15:33:33 +02:00
TransactionRecord *data = priv->index(row);
2011-05-27 08:20:23 +02:00
if(data)
{
2011-06-01 15:33:33 +02:00
return createIndex(row, column, priv->index(row));
2011-06-07 18:59:01 +02:00
}
return QModelIndex();
2011-05-27 08:20:23 +02:00
}
void TransactionTableModel::updateDisplayUnit()
{
// emit dataChanged to update Amount column with the current unit
updateAmountColumnTitle();
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, CWallet *wallet, const uint256 &hash, ChangeType status)
{
// Find transaction in wallet
std::map<uint256, CWalletTx>::iterator mi = wallet->mapWallet.find(hash);
// Determine whether to show transaction or not (determine this here so that no relocking is needed in GUI thread)
bool inWallet = mi != wallet->mapWallet.end();
bool showTransaction = (inWallet && TransactionRecord::showTransaction(mi->second));
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
wallet->NotifyTransactionChanged.connect(boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
wallet->ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
}
void TransactionTableModel::unsubscribeFromCoreSignals()
{
// Disconnect signals from wallet
wallet->NotifyTransactionChanged.disconnect(boost::bind(NotifyTransactionChanged, this, _1, _2, _3));
wallet->ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
}