No OneTemporary
Actions

Size

107 KB

Subscribers

None

View Options

	diff --git a/src/qt/bitcoinamountfield.cpp b/src/qt/bitcoinamountfield.cpp
	index 25ad0c66a..e047c278b 100644
	--- a/src/qt/bitcoinamountfield.cpp
	+++ b/src/qt/bitcoinamountfield.cpp
	@@ -1,186 +1,231 @@
	// Copyright (c) 2011-2014 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "bitcoinamountfield.h"

	#include "bitcoinunits.h"
	#include "guiconstants.h"
	#include "qvaluecombobox.h"

	#include <QApplication>
	#include <QDoubleSpinBox>
	#include <QHBoxLayout>
	#include <QKeyEvent>
	#include <qmath.h> // for qPow()

	+// QDoubleSpinBox that shows SI-style thin space thousands separators
	+class AmountSpinBox: public QDoubleSpinBox
	+{
	+public:
	+ explicit AmountSpinBox(QWidget *parent):
	+ QDoubleSpinBox(parent)
	+ {
	+ }
	+ QString textFromValue(double value) const
	+ {
	+ QStringList parts = QDoubleSpinBox::textFromValue(value).split(".");
	+ QString quotient_str = parts[0];
	+ QString remainder_str;
	+ if(parts.size() > 1)
	+ remainder_str = parts[1];
	+
	+ // Code duplication between here and BitcoinUnits::format
	+ // TODO: Figure out how to share this code
	+ QChar thin_sp(THIN_SP_CP);
	+ int q_size = quotient_str.size();
	+ if (q_size > 4)
	+ for (int i = 3; i < q_size; i += 3)
	+ quotient_str.insert(q_size - i, thin_sp);
	+
	+ int r_size = remainder_str.size();
	+ if (r_size > 4)
	+ for (int i = 3, adj = 0; i < r_size; i += 3, adj++)
	+ remainder_str.insert(i + adj, thin_sp);
	+
	+ if(remainder_str.isEmpty())
	+ return quotient_str;
	+ else
	+ return quotient_str + QString(".") + remainder_str;
	+ }
	+ QValidator::State validate (QString &text, int &pos) const
	+ {
	+ QString s(BitcoinUnits::removeSpaces(text));
	+ return QDoubleSpinBox::validate(s, pos);
	+ }
	+ double valueFromText(const QString& text) const
	+ {
	+ return QDoubleSpinBox::valueFromText(BitcoinUnits::removeSpaces(text));
	+ }
	+};
	+
	BitcoinAmountField::BitcoinAmountField(QWidget *parent) :
	QWidget(parent),
	amount(0),
	currentUnit(-1)
	{
	nSingleStep = 100000; // satoshis

	- amount = new QDoubleSpinBox(this);
	+ amount = new AmountSpinBox(this);
	amount->setLocale(QLocale::c());
	amount->installEventFilter(this);
	amount->setMaximumWidth(170);

	QHBoxLayout *layout = new QHBoxLayout(this);
	layout->addWidget(amount);
	unit = new QValueComboBox(this);
	unit->setModel(new BitcoinUnits(this));
	layout->addWidget(unit);
	layout->addStretch(1);
	layout->setContentsMargins(0,0,0,0);

	setLayout(layout);

	setFocusPolicy(Qt::TabFocus);
	setFocusProxy(amount);

	// If one if the widgets changes, the combined content changes as well
	connect(amount, SIGNAL(valueChanged(QString)), this, SIGNAL(textChanged()));
	connect(unit, SIGNAL(currentIndexChanged(int)), this, SLOT(unitChanged(int)));

	// Set default based on configuration
	unitChanged(unit->currentIndex());
	}

	void BitcoinAmountField::setText(const QString &text)
	{
	if (text.isEmpty())
	amount->clear();
	else
	- amount->setValue(text.toDouble());
	+ amount->setValue(BitcoinUnits::removeSpaces(text).toDouble());
	}

	void BitcoinAmountField::clear()
	{
	amount->clear();
	unit->setCurrentIndex(0);
	}

	bool BitcoinAmountField::validate()
	{
	bool valid = true;
	if (amount->value() == 0.0)
	valid = false;
	else if (!BitcoinUnits::parse(currentUnit, text(), 0))
	valid = false;
	else if (amount->value() > BitcoinUnits::maxAmount(currentUnit))
	valid = false;

	setValid(valid);

	return valid;
	}

	void BitcoinAmountField::setValid(bool valid)
	{
	if (valid)
	amount->setStyleSheet("");
	else
	amount->setStyleSheet(STYLE_INVALID);
	}

	QString BitcoinAmountField::text() const
	{
	if (amount->text().isEmpty())
	return QString();
	else
	return amount->text();
	}

	bool BitcoinAmountField::eventFilter(QObject object, QEvent event)
	{
	if (event->type() == QEvent::FocusIn)
	{
	// Clear invalid flag on focus
	setValid(true);
	}
	else if (event->type() == QEvent::KeyPress \|\| event->type() == QEvent::KeyRelease)
	{
	QKeyEvent keyEvent = static_cast<QKeyEvent >(event);
	if (keyEvent->key() == Qt::Key_Comma)
	{
	// Translate a comma into a period
	QKeyEvent periodKeyEvent(event->type(), Qt::Key_Period, keyEvent->modifiers(), ".", keyEvent->isAutoRepeat(), keyEvent->count());
	QApplication::sendEvent(object, &periodKeyEvent);
	return true;
	}
	}
	return QWidget::eventFilter(object, event);
	}

	QWidget BitcoinAmountField::setupTabChain(QWidget prev)
	{
	QWidget::setTabOrder(prev, amount);
	QWidget::setTabOrder(amount, unit);
	return unit;
	}

	qint64 BitcoinAmountField::value(bool *valid_out) const
	{
	qint64 val_out = 0;
	bool valid = BitcoinUnits::parse(currentUnit, text(), &val_out);
	if (valid_out)
	{
	*valid_out = valid;
	}
	return val_out;
	}

	void BitcoinAmountField::setValue(qint64 value)
	{
	setText(BitcoinUnits::format(currentUnit, value));
	}

	void BitcoinAmountField::setReadOnly(bool fReadOnly)
	{
	amount->setReadOnly(fReadOnly);
	unit->setEnabled(!fReadOnly);
	}

	void BitcoinAmountField::unitChanged(int idx)
	{
	// Use description tooltip for current unit for the combobox
	unit->setToolTip(unit->itemData(idx, Qt::ToolTipRole).toString());

	// Determine new unit ID
	int newUnit = unit->itemData(idx, BitcoinUnits::UnitRole).toInt();

	// Parse current value and convert to new unit
	bool valid = false;
	qint64 currentValue = value(&valid);

	currentUnit = newUnit;

	// Set max length after retrieving the value, to prevent truncation
	amount->setDecimals(BitcoinUnits::decimals(currentUnit));
	amount->setMaximum(qPow(10, BitcoinUnits::amountDigits(currentUnit)) - qPow(10, -amount->decimals()));
	amount->setSingleStep((double)nSingleStep / (double)BitcoinUnits::factor(currentUnit));

	if (valid)
	{
	// If value was valid, re-place it in the widget with the new unit
	setValue(currentValue);
	}
	else
	{
	// If current value is invalid, just clear field
	setText("");
	}
	setValid(true);
	}

	void BitcoinAmountField::setDisplayUnit(int newUnit)
	{
	unit->setValue(newUnit);
	}

	void BitcoinAmountField::setSingleStep(qint64 step)
	{
	nSingleStep = step;
	unitChanged(unit->currentIndex());
	}
	diff --git a/src/qt/bitcoinunits.cpp b/src/qt/bitcoinunits.cpp
	index 2fed443cf..1b5eaa2dc 100644
	--- a/src/qt/bitcoinunits.cpp
	+++ b/src/qt/bitcoinunits.cpp
	@@ -1,196 +1,223 @@
	// Copyright (c) 2011-2013 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "bitcoinunits.h"

	#include <QStringList>

	BitcoinUnits::BitcoinUnits(QObject *parent):
	QAbstractListModel(parent),
	unitlist(availableUnits())
	{
	}

	QList<BitcoinUnits::Unit> BitcoinUnits::availableUnits()
	{
	QList<BitcoinUnits::Unit> unitlist;
	unitlist.append(BTC);
	unitlist.append(mBTC);
	unitlist.append(uBTC);
	return unitlist;
	}

	bool BitcoinUnits::valid(int unit)
	{
	switch(unit)
	{
	case BTC:
	case mBTC:
	case uBTC:
	return true;
	default:
	return false;
	}
	}

	QString BitcoinUnits::name(int unit)
	{
	switch(unit)
	{
	case BTC: return QString("BTC");
	case mBTC: return QString("mBTC");
	case uBTC: return QString::fromUtf8("μBTC");
	default: return QString("???");
	}
	}

	QString BitcoinUnits::description(int unit)
	{
	switch(unit)
	{
	case BTC: return QString("Bitcoins");
	- case mBTC: return QString("Milli-Bitcoins (1 / 1,000)");
	- case uBTC: return QString("Micro-Bitcoins (1 / 1,000,000)");
	+ case mBTC: return QString("Milli-Bitcoins (1 / 1" THIN_SP_UTF8 "000)");
	+ case uBTC: return QString("Micro-Bitcoins (1 / 1" THIN_SP_UTF8 "000" THIN_SP_UTF8 "000)");
	default: return QString("???");
	}
	}

	qint64 BitcoinUnits::factor(int unit)
	{
	switch(unit)
	{
	case BTC: return 100000000;
	case mBTC: return 100000;
	case uBTC: return 100;
	default: return 100000000;
	}
	}

	qint64 BitcoinUnits::maxAmount(int unit)
	{
	switch(unit)
	{
	case BTC: return Q_INT64_C(21000000);
	case mBTC: return Q_INT64_C(21000000000);
	case uBTC: return Q_INT64_C(21000000000000);
	default: return 0;
	}
	}

	int BitcoinUnits::amountDigits(int unit)
	{
	switch(unit)
	{
	case BTC: return 8; // 21,000,000 (# digits, without commas)
	case mBTC: return 11; // 21,000,000,000
	case uBTC: return 14; // 21,000,000,000,000
	default: return 0;
	}
	}

	int BitcoinUnits::decimals(int unit)
	{
	switch(unit)
	{
	case BTC: return 8;
	case mBTC: return 5;
	case uBTC: return 2;
	default: return 0;
	}
	}

	-QString BitcoinUnits::format(int unit, qint64 n, bool fPlus)
	+QString BitcoinUnits::format(int unit, qint64 n, bool fPlus, SeparatorStyle separators, bool fAlign)
	{
	// Note: not using straight sprintf here because we do NOT want
	// localized number formatting.
	if(!valid(unit))
	return QString(); // Refuse to format invalid unit
	qint64 coin = factor(unit);
	int num_decimals = decimals(unit);
	qint64 n_abs = (n > 0 ? n : -n);
	qint64 quotient = n_abs / coin;
	qint64 remainder = n_abs % coin;
	QString quotient_str = QString::number(quotient);
	QString remainder_str = QString::number(remainder).rightJustified(num_decimals, '0');

	// Right-trim excess zeros after the decimal point
	int nTrim = 0;
	for (int i = remainder_str.size()-1; i>=2 && (remainder_str.at(i) == '0'); --i)
	++nTrim;
	remainder_str.chop(nTrim);
	+ if (fAlign)
	+ remainder_str.append(QString(QChar(FIGURE_SP_CP)).repeated(nTrim));
	+
	+ // Use SI-stule separators as these are locale indendent and can't be
	+ // confused with the decimal marker. Rule is to use a thin space every
	+ // three digits on both sides of the decimal point - but only if there
	+ // are five or more digits
	+ QChar thin_sp(THIN_SP_CP);
	+ int q_size = quotient_str.size();
	+ if (separators == separatorAlways \|\| (separators == separatorStandard && q_size > 4))
	+ for (int i = 3; i < q_size; i += 3)
	+ quotient_str.insert(q_size - i, thin_sp);
	+
	+ int r_size = remainder_str.size();
	+ if (separators == separatorAlways \|\| (separators == separatorStandard && r_size > 4))
	+ for (int i = 3, adj = 0; i < r_size ; i += 3, adj++)
	+ remainder_str.insert(i + adj, thin_sp);

	if (n < 0)
	quotient_str.insert(0, '-');
	else if (fPlus && n > 0)
	quotient_str.insert(0, '+');
	return quotient_str + QString(".") + remainder_str;
	}

	-QString BitcoinUnits::formatWithUnit(int unit, qint64 amount, bool plussign)
	+QString BitcoinUnits::formatWithUnit(int unit, qint64 amount, bool plussign, SeparatorStyle separators, bool fAlign)
	{
	- return format(unit, amount, plussign) + QString(" ") + name(unit);
	+ return format(unit, amount, plussign, separators, fAlign) + QString(" ") + name(unit);
	}

	+QString BitcoinUnits::formatHtmlWithUnit(int unit, qint64 amount, bool plussign, SeparatorStyle separators)
	+{
	+ QString str(formatWithUnit(unit, amount, plussign, separators));
	+ str.replace(QChar(THIN_SP_CP), QString(THIN_SP_HTML));
	+ return QString("<span style='white-space: nowrap;'>%1</span>").arg(str);
	+}
	+
	+
	bool BitcoinUnits::parse(int unit, const QString &value, qint64 *val_out)
	{
	if(!valid(unit) \|\| value.isEmpty())
	return false; // Refuse to parse invalid unit or empty string
	int num_decimals = decimals(unit);
	- QStringList parts = value.split(".");
	+
	+ // Ignore spaces and thin spaces when parsing
	+ QStringList parts = removeSpaces(value).split(".");

	if(parts.size() > 2)
	{
	return false; // More than one dot
	}
	QString whole = parts[0];
	QString decimals;

	if(parts.size() > 1)
	{
	decimals = parts[1];
	}
	if(decimals.size() > num_decimals)
	{
	return false; // Exceeds max precision
	}
	bool ok = false;
	QString str = whole + decimals.leftJustified(num_decimals, '0');

	if(str.size() > 18)
	{
	return false; // Longer numbers will exceed 63 bits
	}
	qint64 retvalue = str.toLongLong(&ok);
	if(val_out)
	{
	*val_out = retvalue;
	}
	return ok;
	}

	int BitcoinUnits::rowCount(const QModelIndex &parent) const
	{
	Q_UNUSED(parent);
	return unitlist.size();
	}

	QVariant BitcoinUnits::data(const QModelIndex &index, int role) const
	{
	int row = index.row();
	if(row >= 0 && row < unitlist.size())
	{
	Unit unit = unitlist.at(row);
	switch(role)
	{
	case Qt::EditRole:
	case Qt::DisplayRole:
	return QVariant(name(unit));
	case Qt::ToolTipRole:
	return QVariant(description(unit));
	case UnitRole:
	return QVariant(static_cast<int>(unit));
	}
	}
	return QVariant();
	}
	diff --git a/src/qt/bitcoinunits.h b/src/qt/bitcoinunits.h
	index 46517fc07..a3017b9a8 100644
	--- a/src/qt/bitcoinunits.h
	+++ b/src/qt/bitcoinunits.h
	@@ -1,75 +1,124 @@
	// Copyright (c) 2011-2013 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef BITCOINUNITS_H
	#define BITCOINUNITS_H

	#include <QAbstractListModel>
	#include <QString>

	+// U+2009 THIN SPACE = UTF-8 E2 80 89
	+#define REAL_THIN_SP_CP 0x2009
	+#define REAL_THIN_SP_UTF8 "\xE2\x80\x89"
	+#define REAL_THIN_SP_HTML " "
	+
	+// U+200A HAIR SPACE = UTF-8 E2 80 8A
	+#define HAIR_SP_CP 0x200A
	+#define HAIR_SP_UTF8 "\xE2\x80\x8A"
	+#define HAIR_SP_HTML " "
	+
	+// U+2006 SIX-PER-EM SPACE = UTF-8 E2 80 86
	+#define SIXPEREM_SP_CP 0x2006
	+#define SIXPEREM_SP_UTF8 "\xE2\x80\x86"
	+#define SIXPEREM_SP_HTML " "
	+
	+// U+2007 FIGURE SPACE = UTF-8 E2 80 87
	+#define FIGURE_SP_CP 0x2007
	+#define FIGURE_SP_UTF8 "\xE2\x80\x87"
	+#define FIGURE_SP_HTML " "
	+
	+// QMessageBox seems to have a bug whereby it doesn't display thin/hair spaces
	+// correctly. Workaround is to display a space in a small font. If you
	+// change this, please test that it doesn't cause the parent span to start
	+// wrapping.
	+#define HTML_HACK_SP "<span style='white-space: nowrap; font-size: 6pt'> </span>"
	+
	+// Define THIN_SP_* variables to be our preferred type of thin space
	+#define THIN_SP_CP REAL_THIN_SP_CP
	+#define THIN_SP_UTF8 REAL_THIN_SP_UTF8
	+#define THIN_SP_HTML HTML_HACK_SP
	+
	/** Bitcoin unit definitions. Encapsulates parsing and formatting
	and serves as list model for drop-down selection boxes.
	*/
	class BitcoinUnits: public QAbstractListModel
	{
	Q_OBJECT

	public:
	explicit BitcoinUnits(QObject *parent);

	/** Bitcoin units.
	@note Source: https://en.bitcoin.it/wiki/Units . Please add only sensible ones
	*/
	enum Unit
	{
	BTC,
	mBTC,
	uBTC
	};

	+ enum SeparatorStyle
	+ {
	+ separatorNever,
	+ separatorStandard,
	+ separatorAlways
	+ };
	+
	//! @name Static API
	//! Unit conversion and formatting
	///@{

	//! Get list of units, for drop-down box
	static QList<Unit> availableUnits();
	//! Is unit ID valid?
	static bool valid(int unit);
	//! Short name
	static QString name(int unit);
	//! Longer description
	static QString description(int unit);
	//! Number of Satoshis (1e-8) per unit
	static qint64 factor(int unit);
	//! Max amount per unit
	static qint64 maxAmount(int unit);
	//! Number of amount digits (to represent max number of coins)
	static int amountDigits(int unit);
	//! Number of decimals left
	static int decimals(int unit);
	//! Format as string
	- static QString format(int unit, qint64 amount, bool plussign=false);
	+ static QString format(int unit, qint64 amount, bool plussign=false, SeparatorStyle separators=separatorStandard, bool fAlign=false);
	//! Format as string (with unit)
	- static QString formatWithUnit(int unit, qint64 amount, bool plussign=false);
	+ static QString formatWithUnit(int unit, qint64 amount, bool plussign=false, SeparatorStyle separators=separatorStandard, bool fAlign=false);
	+ static QString formatHtmlWithUnit(int unit, qint64 amount, bool plussign=false, SeparatorStyle separators=separatorStandard);
	//! Parse string to coin amount
	static bool parse(int unit, const QString &value, qint64 *val_out);
	///@}

	//! @name AbstractListModel implementation
	//! List model for unit drop-down selection box.
	///@{
	enum RoleIndex {
	/** Unit identifier */
	UnitRole = Qt::UserRole
	};
	int rowCount(const QModelIndex &parent) const;
	QVariant data(const QModelIndex &index, int role) const;
	///@}

	+ static QString removeSpaces(QString text)
	+ {
	+ text.remove(' ');
	+ text.remove(QChar(THIN_SP_CP));
	+#if (THIN_SP_CP != REAL_THIN_SP_CP)
	+ text.remove(QChar(REAL_THIN_SP_CP));
	+#endif
	+ return text;
	+ }
	+
	private:
	QList<BitcoinUnits::Unit> unitlist;
	};
	typedef BitcoinUnits::Unit BitcoinUnit;

	#endif // BITCOINUNITS_H
	diff --git a/src/qt/overviewpage.cpp b/src/qt/overviewpage.cpp
	index 1a9d1de57..311563d94 100644
	--- a/src/qt/overviewpage.cpp
	+++ b/src/qt/overviewpage.cpp
	@@ -1,219 +1,219 @@
	// Copyright (c) 2011-2013 The Bitcoin 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 "guiconstants.h"
	#include "guiutil.h"
	#include "optionsmodel.h"
	#include "transactionfilterproxy.h"
	#include "transactiontablemodel.h"
	#include "walletmodel.h"

	#include <QAbstractItemDelegate>
	#include <QPainter>

	#define DECORATION_SIZE 64
	#define NUM_ITEMS 3

	class TxViewDelegate : public QAbstractItemDelegate
	{
	Q_OBJECT
	public:
	TxViewDelegate(): QAbstractItemDelegate(), unit(BitcoinUnits::BTC)
	{

	}

	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;
	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, 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);
	painter->drawText(addressRect, Qt::AlignLeft\|Qt::AlignVCenter, address);

	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);
	+ QString amountText = BitcoinUnits::formatWithUnit(unit, amount, true, BitcoinUnits::separatorAlways, true);
	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),
	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->labelTransactionsStatus->setText("(" + tr("out of sync") + ")");

	// 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()
	{
	delete ui;
	}

	void OverviewPage::setBalance(qint64 balance, qint64 unconfirmedBalance, qint64 immatureBalance)
	{
	int unit = walletModel->getOptionsModel()->getDisplayUnit();
	currentBalance = balance;
	currentUnconfirmedBalance = unconfirmedBalance;
	currentImmatureBalance = immatureBalance;
	- ui->labelBalance->setText(BitcoinUnits::formatWithUnit(unit, balance));
	- ui->labelUnconfirmed->setText(BitcoinUnits::formatWithUnit(unit, unconfirmedBalance));
	- ui->labelImmature->setText(BitcoinUnits::formatWithUnit(unit, immatureBalance));
	- ui->labelTotal->setText(BitcoinUnits::formatWithUnit(unit, balance + unconfirmedBalance + immatureBalance));
	+ ui->labelBalance->setText(BitcoinUnits::formatWithUnit(unit, balance, false, BitcoinUnits::separatorAlways, true));
	+ ui->labelUnconfirmed->setText(BitcoinUnits::formatWithUnit(unit, unconfirmedBalance, false, BitcoinUnits::separatorAlways, true));
	+ ui->labelImmature->setText(BitcoinUnits::formatWithUnit(unit, immatureBalance, false, BitcoinUnits::separatorAlways, true));
	+ ui->labelTotal->setText(BitcoinUnits::formatWithUnit(unit, balance + unconfirmedBalance + immatureBalance, false, BitcoinUnits::separatorAlways, true));

	// 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;
	ui->labelImmature->setVisible(showImmature);
	ui->labelImmatureText->setVisible(showImmature);
	}

	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());
	connect(model, SIGNAL(balanceChanged(qint64, qint64, qint64)), this, SLOT(setBalance(qint64, qint64, qint64)));

	connect(model->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));
	}

	// update the display unit, to not use the default ("BTC")
	updateDisplayUnit();
	}

	void OverviewPage::updateDisplayUnit()
	{
	if(walletModel && walletModel->getOptionsModel())
	{
	if(currentBalance != -1)
	setBalance(currentBalance, currentUnconfirmedBalance, currentImmatureBalance);

	// Update txdelegate->unit with the current unit
	txdelegate->unit = walletModel->getOptionsModel()->getDisplayUnit();

	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->labelTransactionsStatus->setVisible(fShow);
	}
	diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
	index 33621e54b..f432c4add 100644
	--- a/src/qt/sendcoinsdialog.cpp
	+++ b/src/qt/sendcoinsdialog.cpp
	@@ -1,623 +1,623 @@
	// Copyright (c) 2011-2014 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "sendcoinsdialog.h"
	#include "ui_sendcoinsdialog.h"

	#include "addresstablemodel.h"
	#include "bitcoinunits.h"
	#include "coincontroldialog.h"
	#include "guiutil.h"
	#include "optionsmodel.h"
	#include "sendcoinsentry.h"
	#include "walletmodel.h"

	#include "base58.h"
	#include "coincontrol.h"
	#include "ui_interface.h"

	#include <QMessageBox>
	#include <QScrollBar>
	#include <QTextDocument>

	SendCoinsDialog::SendCoinsDialog(QWidget *parent) :
	QDialog(parent),
	ui(new Ui::SendCoinsDialog),
	model(0)
	{
	ui->setupUi(this);

	#ifdef Q_OS_MAC // Icons on push buttons are very uncommon on Mac
	ui->addButton->setIcon(QIcon());
	ui->clearButton->setIcon(QIcon());
	ui->sendButton->setIcon(QIcon());
	#endif

	GUIUtil::setupAddressWidget(ui->lineEditCoinControlChange, this);

	addEntry();

	connect(ui->addButton, SIGNAL(clicked()), this, SLOT(addEntry()));
	connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));

	// Coin Control
	connect(ui->pushButtonCoinControl, SIGNAL(clicked()), this, SLOT(coinControlButtonClicked()));
	connect(ui->checkBoxCoinControlChange, SIGNAL(stateChanged(int)), this, SLOT(coinControlChangeChecked(int)));
	connect(ui->lineEditCoinControlChange, SIGNAL(textEdited(const QString &)), this, SLOT(coinControlChangeEdited(const QString &)));

	// Coin Control: clipboard actions
	QAction *clipboardQuantityAction = new QAction(tr("Copy quantity"), this);
	QAction *clipboardAmountAction = new QAction(tr("Copy amount"), this);
	QAction *clipboardFeeAction = new QAction(tr("Copy fee"), this);
	QAction *clipboardAfterFeeAction = new QAction(tr("Copy after fee"), this);
	QAction *clipboardBytesAction = new QAction(tr("Copy bytes"), this);
	QAction *clipboardPriorityAction = new QAction(tr("Copy priority"), this);
	QAction *clipboardLowOutputAction = new QAction(tr("Copy low output"), this);
	QAction *clipboardChangeAction = new QAction(tr("Copy change"), this);
	connect(clipboardQuantityAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardQuantity()));
	connect(clipboardAmountAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardAmount()));
	connect(clipboardFeeAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardFee()));
	connect(clipboardAfterFeeAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardAfterFee()));
	connect(clipboardBytesAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardBytes()));
	connect(clipboardPriorityAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardPriority()));
	connect(clipboardLowOutputAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardLowOutput()));
	connect(clipboardChangeAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardChange()));
	ui->labelCoinControlQuantity->addAction(clipboardQuantityAction);
	ui->labelCoinControlAmount->addAction(clipboardAmountAction);
	ui->labelCoinControlFee->addAction(clipboardFeeAction);
	ui->labelCoinControlAfterFee->addAction(clipboardAfterFeeAction);
	ui->labelCoinControlBytes->addAction(clipboardBytesAction);
	ui->labelCoinControlPriority->addAction(clipboardPriorityAction);
	ui->labelCoinControlLowOutput->addAction(clipboardLowOutputAction);
	ui->labelCoinControlChange->addAction(clipboardChangeAction);

	fNewRecipientAllowed = true;
	}

	void SendCoinsDialog::setModel(WalletModel *model)
	{
	this->model = model;

	if(model && model->getOptionsModel())
	{
	for(int i = 0; i < ui->entries->count(); ++i)
	{
	SendCoinsEntry entry = qobject_cast<SendCoinsEntry>(ui->entries->itemAt(i)->widget());
	if(entry)
	{
	entry->setModel(model);
	}
	}

	setBalance(model->getBalance(), model->getUnconfirmedBalance(), model->getImmatureBalance());
	connect(model, SIGNAL(balanceChanged(qint64, qint64, qint64)), this, SLOT(setBalance(qint64, qint64, qint64)));
	connect(model->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));

	// Coin Control
	connect(model->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this, SLOT(coinControlUpdateLabels()));
	connect(model->getOptionsModel(), SIGNAL(coinControlFeaturesChanged(bool)), this, SLOT(coinControlFeatureChanged(bool)));
	connect(model->getOptionsModel(), SIGNAL(transactionFeeChanged(qint64)), this, SLOT(coinControlUpdateLabels()));
	ui->frameCoinControl->setVisible(model->getOptionsModel()->getCoinControlFeatures());
	coinControlUpdateLabels();
	}
	}

	SendCoinsDialog::~SendCoinsDialog()
	{
	delete ui;
	}

	void SendCoinsDialog::on_sendButton_clicked()
	{
	if(!model \|\| !model->getOptionsModel())
	return;

	QList<SendCoinsRecipient> recipients;
	bool valid = true;

	for(int i = 0; i < ui->entries->count(); ++i)
	{
	SendCoinsEntry entry = qobject_cast<SendCoinsEntry>(ui->entries->itemAt(i)->widget());
	if(entry)
	{
	if(entry->validate())
	{
	recipients.append(entry->getValue());
	}
	else
	{
	valid = false;
	}
	}
	}

	if(!valid \|\| recipients.isEmpty())
	{
	return;
	}

	// Format confirmation message
	QStringList formatted;
	foreach(const SendCoinsRecipient &rcp, recipients)
	{
	// generate bold amount string
	- QString amount = "<b>" + BitcoinUnits::formatWithUnit(model->getOptionsModel()->getDisplayUnit(), rcp.amount);
	+ QString amount = "<b>" + BitcoinUnits::formatHtmlWithUnit(model->getOptionsModel()->getDisplayUnit(), rcp.amount);
	amount.append("</b>");
	// generate monospace address string
	QString address = "<span style='font-family: monospace;'>" + rcp.address;
	address.append("</span>");

	QString recipientElement;

	if (!rcp.paymentRequest.IsInitialized()) // normal payment
	{
	if(rcp.label.length() > 0) // label with address
	{
	recipientElement = tr("%1 to %2").arg(amount, GUIUtil::HtmlEscape(rcp.label));
	recipientElement.append(QString(" (%1)").arg(address));
	}
	else // just address
	{
	recipientElement = tr("%1 to %2").arg(amount, address);
	}
	}
	else if(!rcp.authenticatedMerchant.isEmpty()) // secure payment request
	{
	recipientElement = tr("%1 to %2").arg(amount, GUIUtil::HtmlEscape(rcp.authenticatedMerchant));
	}
	else // insecure payment request
	{
	recipientElement = tr("%1 to %2").arg(amount, address);
	}

	formatted.append(recipientElement);
	}

	fNewRecipientAllowed = false;


	WalletModel::UnlockContext ctx(model->requestUnlock());
	if(!ctx.isValid())
	{
	// Unlock wallet was cancelled
	fNewRecipientAllowed = true;
	return;
	}

	// prepare transaction for getting txFee earlier
	WalletModelTransaction currentTransaction(recipients);
	WalletModel::SendCoinsReturn prepareStatus;
	if (model->getOptionsModel()->getCoinControlFeatures()) // coin control enabled
	prepareStatus = model->prepareTransaction(currentTransaction, CoinControlDialog::coinControl);
	else
	prepareStatus = model->prepareTransaction(currentTransaction);

	// process prepareStatus and on error generate message shown to user
	processSendCoinsReturn(prepareStatus,
	BitcoinUnits::formatWithUnit(model->getOptionsModel()->getDisplayUnit(), currentTransaction.getTransactionFee()));

	if(prepareStatus.status != WalletModel::OK) {
	fNewRecipientAllowed = true;
	return;
	}

	qint64 txFee = currentTransaction.getTransactionFee();
	QString questionString = tr("Are you sure you want to send?");
	questionString.append("<br /><br />%1");

	if(txFee > 0)
	{
	// append fee string if a fee is required
	questionString.append("<hr /><span style='color:#aa0000;'>");
	- questionString.append(BitcoinUnits::formatWithUnit(model->getOptionsModel()->getDisplayUnit(), txFee));
	+ questionString.append(BitcoinUnits::formatHtmlWithUnit(model->getOptionsModel()->getDisplayUnit(), txFee));
	questionString.append("</span> ");
	questionString.append(tr("added as transaction fee"));
	}

	// add total amount in all subdivision units
	questionString.append("<hr />");
	qint64 totalAmount = currentTransaction.getTotalTransactionAmount() + txFee;
	QStringList alternativeUnits;
	foreach(BitcoinUnits::Unit u, BitcoinUnits::availableUnits())
	{
	if(u != model->getOptionsModel()->getDisplayUnit())
	- alternativeUnits.append(BitcoinUnits::formatWithUnit(u, totalAmount));
	+ alternativeUnits.append(BitcoinUnits::formatHtmlWithUnit(u, totalAmount));
	}
	questionString.append(tr("Total Amount %1 (= %2)")
	- .arg(BitcoinUnits::formatWithUnit(model->getOptionsModel()->getDisplayUnit(), totalAmount))
	+ .arg(BitcoinUnits::formatHtmlWithUnit(model->getOptionsModel()->getDisplayUnit(), totalAmount))
	.arg(alternativeUnits.join(" " + tr("or") + " ")));

	QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm send coins"),
	questionString.arg(formatted.join("<br />")),
	QMessageBox::Yes \| QMessageBox::Cancel,
	QMessageBox::Cancel);

	if(retval != QMessageBox::Yes)
	{
	fNewRecipientAllowed = true;
	return;
	}

	// now send the prepared transaction
	WalletModel::SendCoinsReturn sendStatus = model->sendCoins(currentTransaction);
	// process sendStatus and on error generate message shown to user
	processSendCoinsReturn(sendStatus);

	if (sendStatus.status == WalletModel::OK)
	{
	accept();
	CoinControlDialog::coinControl->UnSelectAll();
	coinControlUpdateLabels();
	}
	fNewRecipientAllowed = true;
	}

	void SendCoinsDialog::clear()
	{
	// Remove entries until only one left
	while(ui->entries->count())
	{
	ui->entries->takeAt(0)->widget()->deleteLater();
	}
	addEntry();

	updateTabsAndLabels();
	}

	void SendCoinsDialog::reject()
	{
	clear();
	}

	void SendCoinsDialog::accept()
	{
	clear();
	}

	SendCoinsEntry *SendCoinsDialog::addEntry()
	{
	SendCoinsEntry *entry = new SendCoinsEntry(this);
	entry->setModel(model);
	ui->entries->addWidget(entry);
	connect(entry, SIGNAL(removeEntry(SendCoinsEntry)), this, SLOT(removeEntry(SendCoinsEntry)));
	connect(entry, SIGNAL(payAmountChanged()), this, SLOT(coinControlUpdateLabels()));

	updateTabsAndLabels();

	// Focus the field, so that entry can start immediately
	entry->clear();
	entry->setFocus();
	ui->scrollAreaWidgetContents->resize(ui->scrollAreaWidgetContents->sizeHint());
	qApp->processEvents();
	QScrollBar* bar = ui->scrollArea->verticalScrollBar();
	if(bar)
	bar->setSliderPosition(bar->maximum());
	return entry;
	}

	void SendCoinsDialog::updateTabsAndLabels()
	{
	setupTabChain(0);
	coinControlUpdateLabels();
	}

	void SendCoinsDialog::removeEntry(SendCoinsEntry* entry)
	{
	entry->hide();

	// If the last entry is about to be removed add an empty one
	if (ui->entries->count() == 1)
	addEntry();

	entry->deleteLater();

	updateTabsAndLabels();
	}

	QWidget SendCoinsDialog::setupTabChain(QWidget prev)
	{
	for(int i = 0; i < ui->entries->count(); ++i)
	{
	SendCoinsEntry entry = qobject_cast<SendCoinsEntry>(ui->entries->itemAt(i)->widget());
	if(entry)
	{
	prev = entry->setupTabChain(prev);
	}
	}
	QWidget::setTabOrder(prev, ui->sendButton);
	QWidget::setTabOrder(ui->sendButton, ui->clearButton);
	QWidget::setTabOrder(ui->clearButton, ui->addButton);
	return ui->addButton;
	}

	void SendCoinsDialog::setAddress(const QString &address)
	{
	SendCoinsEntry *entry = 0;
	// Replace the first entry if it is still unused
	if(ui->entries->count() == 1)
	{
	SendCoinsEntry first = qobject_cast<SendCoinsEntry>(ui->entries->itemAt(0)->widget());
	if(first->isClear())
	{
	entry = first;
	}
	}
	if(!entry)
	{
	entry = addEntry();
	}

	entry->setAddress(address);
	}

	void SendCoinsDialog::pasteEntry(const SendCoinsRecipient &rv)
	{
	if(!fNewRecipientAllowed)
	return;

	SendCoinsEntry *entry = 0;
	// Replace the first entry if it is still unused
	if(ui->entries->count() == 1)
	{
	SendCoinsEntry first = qobject_cast<SendCoinsEntry>(ui->entries->itemAt(0)->widget());
	if(first->isClear())
	{
	entry = first;
	}
	}
	if(!entry)
	{
	entry = addEntry();
	}

	entry->setValue(rv);
	updateTabsAndLabels();
	}

	bool SendCoinsDialog::handlePaymentRequest(const SendCoinsRecipient &rv)
	{
	QString strSendCoins = tr("Send Coins");
	if (rv.paymentRequest.IsInitialized()) {
	// Expired payment request?
	const payments::PaymentDetails& details = rv.paymentRequest.getDetails();
	if (details.has_expires() && (int64_t)details.expires() < GetTime())
	{
	emit message(strSendCoins, tr("Payment request expired"),
	CClientUIInterface::MSG_WARNING);
	return false;
	}
	}
	else {
	CBitcoinAddress address(rv.address.toStdString());
	if (!address.IsValid()) {
	emit message(strSendCoins, tr("Invalid payment address %1").arg(rv.address),
	CClientUIInterface::MSG_WARNING);
	return false;
	}
	}

	pasteEntry(rv);
	return true;
	}

	void SendCoinsDialog::setBalance(qint64 balance, qint64 unconfirmedBalance, qint64 immatureBalance)
	{
	Q_UNUSED(unconfirmedBalance);
	Q_UNUSED(immatureBalance);

	if(model && model->getOptionsModel())
	{
	ui->labelBalance->setText(BitcoinUnits::formatWithUnit(model->getOptionsModel()->getDisplayUnit(), balance));
	}
	}

	void SendCoinsDialog::updateDisplayUnit()
	{
	setBalance(model->getBalance(), 0, 0);
	}

	void SendCoinsDialog::processSendCoinsReturn(const WalletModel::SendCoinsReturn &sendCoinsReturn, const QString &msgArg)
	{
	QPair<QString, CClientUIInterface::MessageBoxFlags> msgParams;
	// Default to a warning message, override if error message is needed
	msgParams.second = CClientUIInterface::MSG_WARNING;

	// This comment is specific to SendCoinsDialog usage of WalletModel::SendCoinsReturn.
	// WalletModel::TransactionCommitFailed is used only in WalletModel::sendCoins()
	// all others are used only in WalletModel::prepareTransaction()
	switch(sendCoinsReturn.status)
	{
	case WalletModel::InvalidAddress:
	msgParams.first = tr("The recipient address is not valid, please recheck.");
	break;
	case WalletModel::InvalidAmount:
	msgParams.first = tr("The amount to pay must be larger than 0.");
	break;
	case WalletModel::AmountExceedsBalance:
	msgParams.first = tr("The amount exceeds your balance.");
	break;
	case WalletModel::AmountWithFeeExceedsBalance:
	msgParams.first = tr("The total exceeds your balance when the %1 transaction fee is included.").arg(msgArg);
	break;
	case WalletModel::DuplicateAddress:
	msgParams.first = tr("Duplicate address found, can only send to each address once per send operation.");
	break;
	case WalletModel::TransactionCreationFailed:
	msgParams.first = tr("Transaction creation failed!");
	msgParams.second = CClientUIInterface::MSG_ERROR;
	break;
	case WalletModel::TransactionCommitFailed:
	msgParams.first = tr("The transaction was rejected! This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here.");
	msgParams.second = CClientUIInterface::MSG_ERROR;
	break;
	// included to prevent a compiler warning.
	case WalletModel::OK:
	default:
	return;
	}

	emit message(tr("Send Coins"), msgParams.first, msgParams.second);
	}

	// Coin Control: copy label "Quantity" to clipboard
	void SendCoinsDialog::coinControlClipboardQuantity()
	{
	GUIUtil::setClipboard(ui->labelCoinControlQuantity->text());
	}

	// Coin Control: copy label "Amount" to clipboard
	void SendCoinsDialog::coinControlClipboardAmount()
	{
	GUIUtil::setClipboard(ui->labelCoinControlAmount->text().left(ui->labelCoinControlAmount->text().indexOf(" ")));
	}

	// Coin Control: copy label "Fee" to clipboard
	void SendCoinsDialog::coinControlClipboardFee()
	{
	GUIUtil::setClipboard(ui->labelCoinControlFee->text().left(ui->labelCoinControlFee->text().indexOf(" ")));
	}

	// Coin Control: copy label "After fee" to clipboard
	void SendCoinsDialog::coinControlClipboardAfterFee()
	{
	GUIUtil::setClipboard(ui->labelCoinControlAfterFee->text().left(ui->labelCoinControlAfterFee->text().indexOf(" ")));
	}

	// Coin Control: copy label "Bytes" to clipboard
	void SendCoinsDialog::coinControlClipboardBytes()
	{
	GUIUtil::setClipboard(ui->labelCoinControlBytes->text());
	}

	// Coin Control: copy label "Priority" to clipboard
	void SendCoinsDialog::coinControlClipboardPriority()
	{
	GUIUtil::setClipboard(ui->labelCoinControlPriority->text());
	}

	// Coin Control: copy label "Low output" to clipboard
	void SendCoinsDialog::coinControlClipboardLowOutput()
	{
	GUIUtil::setClipboard(ui->labelCoinControlLowOutput->text());
	}

	// Coin Control: copy label "Change" to clipboard
	void SendCoinsDialog::coinControlClipboardChange()
	{
	GUIUtil::setClipboard(ui->labelCoinControlChange->text().left(ui->labelCoinControlChange->text().indexOf(" ")));
	}

	// Coin Control: settings menu - coin control enabled/disabled by user
	void SendCoinsDialog::coinControlFeatureChanged(bool checked)
	{
	ui->frameCoinControl->setVisible(checked);

	if (!checked && model) // coin control features disabled
	CoinControlDialog::coinControl->SetNull();

	if (checked)
	coinControlUpdateLabels();
	}

	// Coin Control: button inputs -> show actual coin control dialog
	void SendCoinsDialog::coinControlButtonClicked()
	{
	CoinControlDialog dlg;
	dlg.setModel(model);
	dlg.exec();
	coinControlUpdateLabels();
	}

	// Coin Control: checkbox custom change address
	void SendCoinsDialog::coinControlChangeChecked(int state)
	{
	if (state == Qt::Unchecked)
	{
	CoinControlDialog::coinControl->destChange = CNoDestination();
	ui->labelCoinControlChangeLabel->clear();
	}
	else
	// use this to re-validate an already entered address
	coinControlChangeEdited(ui->lineEditCoinControlChange->text());

	ui->lineEditCoinControlChange->setEnabled((state == Qt::Checked));
	}

	// Coin Control: custom change address changed
	void SendCoinsDialog::coinControlChangeEdited(const QString& text)
	{
	if (model && model->getAddressTableModel())
	{
	// Default to no change address until verified
	CoinControlDialog::coinControl->destChange = CNoDestination();
	ui->labelCoinControlChangeLabel->setStyleSheet("QLabel{color:red;}");

	CBitcoinAddress addr = CBitcoinAddress(text.toStdString());

	if (text.isEmpty()) // Nothing entered
	{
	ui->labelCoinControlChangeLabel->setText("");
	}
	else if (!addr.IsValid()) // Invalid address
	{
	ui->labelCoinControlChangeLabel->setText(tr("Warning: Invalid Bitcoin address"));
	}
	else // Valid address
	{
	CPubKey pubkey;
	CKeyID keyid;
	addr.GetKeyID(keyid);
	if (!model->getPubKey(keyid, pubkey)) // Unknown change address
	{
	ui->labelCoinControlChangeLabel->setText(tr("Warning: Unknown change address"));
	}
	else // Known change address
	{
	ui->labelCoinControlChangeLabel->setStyleSheet("QLabel{color:black;}");

	// Query label
	QString associatedLabel = model->getAddressTableModel()->labelForAddress(text);
	if (!associatedLabel.isEmpty())
	ui->labelCoinControlChangeLabel->setText(associatedLabel);
	else
	ui->labelCoinControlChangeLabel->setText(tr("(no label)"));

	CoinControlDialog::coinControl->destChange = addr.Get();
	}
	}
	}
	}

	// Coin Control: update labels
	void SendCoinsDialog::coinControlUpdateLabels()
	{
	if (!model \|\| !model->getOptionsModel() \|\| !model->getOptionsModel()->getCoinControlFeatures())
	return;

	// set pay amounts
	CoinControlDialog::payAmounts.clear();
	for(int i = 0; i < ui->entries->count(); ++i)
	{
	SendCoinsEntry entry = qobject_cast<SendCoinsEntry>(ui->entries->itemAt(i)->widget());
	if(entry)
	CoinControlDialog::payAmounts.append(entry->getValue().amount);
	}

	if (CoinControlDialog::coinControl->HasSelected())
	{
	// actual coin control calculation
	CoinControlDialog::updateLabels(model, this);

	// show coin control stats
	ui->labelCoinControlAutomaticallySelected->hide();
	ui->widgetCoinControl->show();
	}
	else
	{
	// hide coin control stats
	ui->labelCoinControlAutomaticallySelected->show();
	ui->widgetCoinControl->hide();
	ui->labelCoinControlInsuffFunds->hide();
	}
	}
	diff --git a/src/qt/transactiondesc.cpp b/src/qt/transactiondesc.cpp
	index 45fb3d40c..0bb93035c 100644
	--- a/src/qt/transactiondesc.cpp
	+++ b/src/qt/transactiondesc.cpp
	@@ -1,303 +1,303 @@
	// Copyright (c) 2011-2014 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "transactiondesc.h"

	#include "bitcoinunits.h"
	#include "guiutil.h"

	#include "base58.h"
	#include "db.h"
	#include "main.h"
	#include "paymentserver.h"
	#include "transactionrecord.h"
	#include "ui_interface.h"
	#include "wallet.h"

	#include <stdint.h>
	#include <string>

	QString TransactionDesc::FormatTxStatus(const CWalletTx& wtx)
	{
	AssertLockHeld(cs_main);
	if (!IsFinalTx(wtx, chainActive.Height() + 1))
	{
	if (wtx.nLockTime < LOCKTIME_THRESHOLD)
	return tr("Open for %n more block(s)", "", wtx.nLockTime - chainActive.Height());
	else
	return tr("Open until %1").arg(GUIUtil::dateTimeStr(wtx.nLockTime));
	}
	else
	{
	int nDepth = wtx.GetDepthInMainChain();
	if (nDepth < 0)
	return tr("conflicted");
	else if (GetAdjustedTime() - wtx.nTimeReceived > 2 * 60 && wtx.GetRequestCount() == 0)
	return tr("%1/offline").arg(nDepth);
	else if (nDepth < 6)
	return tr("%1/unconfirmed").arg(nDepth);
	else
	return tr("%1 confirmations").arg(nDepth);
	}
	}

	QString TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx, int vout, int unit)
	{
	QString strHTML;

	LOCK2(cs_main, wallet->cs_wallet);
	strHTML.reserve(4000);
	strHTML += "<html><font face='verdana, arial, helvetica, sans-serif'>";

	int64_t nTime = wtx.GetTxTime();
	int64_t nCredit = wtx.GetCredit();
	int64_t nDebit = wtx.GetDebit();
	int64_t nNet = nCredit - nDebit;

	strHTML += "<b>" + tr("Status") + ":</b> " + FormatTxStatus(wtx);
	int nRequests = wtx.GetRequestCount();
	if (nRequests != -1)
	{
	if (nRequests == 0)
	strHTML += tr(", has not been successfully broadcast yet");
	else if (nRequests > 0)
	strHTML += tr(", broadcast through %n node(s)", "", nRequests);
	}
	strHTML += "<br>";

	strHTML += "<b>" + tr("Date") + ":</b> " + (nTime ? GUIUtil::dateTimeStr(nTime) : "") + "<br>";

	//
	// From
	//
	if (wtx.IsCoinBase())
	{
	strHTML += "<b>" + tr("Source") + ":</b> " + tr("Generated") + "<br>";
	}
	else if (wtx.mapValue.count("from") && !wtx.mapValue["from"].empty())
	{
	// Online transaction
	strHTML += "<b>" + tr("From") + ":</b> " + GUIUtil::HtmlEscape(wtx.mapValue["from"]) + "<br>";
	}
	else
	{
	// Offline transaction
	if (nNet > 0)
	{
	// Credit
	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	{
	if (wallet->IsMine(txout))
	{
	CTxDestination address;
	if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*wallet, address))
	{
	if (wallet->mapAddressBook.count(address))
	{
	strHTML += "<b>" + tr("From") + ":</b> " + tr("unknown") + "<br>";
	strHTML += "<b>" + tr("To") + ":</b> ";
	strHTML += GUIUtil::HtmlEscape(CBitcoinAddress(address).ToString());
	if (!wallet->mapAddressBook[address].name.empty())
	strHTML += " (" + tr("own address") + ", " + tr("label") + ": " + GUIUtil::HtmlEscape(wallet->mapAddressBook[address].name) + ")";
	else
	strHTML += " (" + tr("own address") + ")";
	strHTML += "<br>";
	}
	}
	break;
	}
	}
	}
	}

	//
	// To
	//
	if (wtx.mapValue.count("to") && !wtx.mapValue["to"].empty())
	{
	// Online transaction
	std::string strAddress = wtx.mapValue["to"];
	strHTML += "<b>" + tr("To") + ":</b> ";
	CTxDestination dest = CBitcoinAddress(strAddress).Get();
	if (wallet->mapAddressBook.count(dest) && !wallet->mapAddressBook[dest].name.empty())
	strHTML += GUIUtil::HtmlEscape(wallet->mapAddressBook[dest].name) + " ";
	strHTML += GUIUtil::HtmlEscape(strAddress) + "<br>";
	}

	//
	// Amount
	//
	if (wtx.IsCoinBase() && nCredit == 0)
	{
	//
	// Coinbase
	//
	int64_t nUnmatured = 0;
	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	nUnmatured += wallet->GetCredit(txout);
	strHTML += "<b>" + tr("Credit") + ":</b> ";
	if (wtx.IsInMainChain())
	- strHTML += BitcoinUnits::formatWithUnit(unit, nUnmatured)+ " (" + tr("matures in %n more block(s)", "", wtx.GetBlocksToMaturity()) + ")";
	+ strHTML += BitcoinUnits::formatHtmlWithUnit(unit, nUnmatured)+ " (" + tr("matures in %n more block(s)", "", wtx.GetBlocksToMaturity()) + ")";
	else
	strHTML += "(" + tr("not accepted") + ")";
	strHTML += "<br>";
	}
	else if (nNet > 0)
	{
	//
	// Credit
	//
	- strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, nNet) + "<br>";
	+ strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, nNet) + "<br>";
	}
	else
	{
	bool fAllFromMe = true;
	BOOST_FOREACH(const CTxIn& txin, wtx.vin)
	fAllFromMe = fAllFromMe && wallet->IsMine(txin);

	bool fAllToMe = true;
	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	fAllToMe = fAllToMe && wallet->IsMine(txout);

	if (fAllFromMe)
	{
	//
	// Debit
	//
	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	{
	if (wallet->IsMine(txout))
	continue;

	if (!wtx.mapValue.count("to") \|\| wtx.mapValue["to"].empty())
	{
	// Offline transaction
	CTxDestination address;
	if (ExtractDestination(txout.scriptPubKey, address))
	{
	strHTML += "<b>" + tr("To") + ":</b> ";
	if (wallet->mapAddressBook.count(address) && !wallet->mapAddressBook[address].name.empty())
	strHTML += GUIUtil::HtmlEscape(wallet->mapAddressBook[address].name) + " ";
	strHTML += GUIUtil::HtmlEscape(CBitcoinAddress(address).ToString());
	strHTML += "<br>";
	}
	}

	- strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, -txout.nValue) + "<br>";
	+ strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -txout.nValue) + "<br>";
	}

	if (fAllToMe)
	{
	// Payment to self
	int64_t nChange = wtx.GetChange();
	int64_t nValue = nCredit - nChange;
	- strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, -nValue) + "<br>";
	- strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, nValue) + "<br>";
	+ strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -nValue) + "<br>";
	+ strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, nValue) + "<br>";
	}

	int64_t nTxFee = nDebit - wtx.GetValueOut();
	if (nTxFee > 0)
	- strHTML += "<b>" + tr("Transaction fee") + ":</b> " + BitcoinUnits::formatWithUnit(unit, -nTxFee) + "<br>";
	+ strHTML += "<b>" + tr("Transaction fee") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -nTxFee) + "<br>";
	}
	else
	{
	//
	// Mixed debit transaction
	//
	BOOST_FOREACH(const CTxIn& txin, wtx.vin)
	if (wallet->IsMine(txin))
	- strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, -wallet->GetDebit(txin)) + "<br>";
	+ strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -wallet->GetDebit(txin)) + "<br>";
	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	if (wallet->IsMine(txout))
	- strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, wallet->GetCredit(txout)) + "<br>";
	+ strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, wallet->GetCredit(txout)) + "<br>";
	}
	}

	- strHTML += "<b>" + tr("Net amount") + ":</b> " + BitcoinUnits::formatWithUnit(unit, nNet, true) + "<br>";
	+ strHTML += "<b>" + tr("Net amount") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, nNet, true) + "<br>";

	//
	// Message
	//
	if (wtx.mapValue.count("message") && !wtx.mapValue["message"].empty())
	strHTML += "<br><b>" + tr("Message") + ":</b><br>" + GUIUtil::HtmlEscape(wtx.mapValue["message"], true) + "<br>";
	if (wtx.mapValue.count("comment") && !wtx.mapValue["comment"].empty())
	strHTML += "<br><b>" + tr("Comment") + ":</b><br>" + GUIUtil::HtmlEscape(wtx.mapValue["comment"], true) + "<br>";

	strHTML += "<b>" + tr("Transaction ID") + ":</b> " + TransactionRecord::formatSubTxId(wtx.GetHash(), vout) + "<br>";

	// Message from normal bitcoin:URI (bitcoin:123...?message=example)
	foreach (const PAIRTYPE(string, string)& r, wtx.vOrderForm)
	if (r.first == "Message")
	strHTML += "<br><b>" + tr("Message") + ":</b><br>" + GUIUtil::HtmlEscape(r.second, true) + "<br>";

	//
	// PaymentRequest info:
	//
	foreach (const PAIRTYPE(string, string)& r, wtx.vOrderForm)
	{
	if (r.first == "PaymentRequest")
	{
	PaymentRequestPlus req;
	req.parse(QByteArray::fromRawData(r.second.data(), r.second.size()));
	QString merchant;
	if (req.getMerchant(PaymentServer::getCertStore(), merchant))
	strHTML += "<b>" + tr("Merchant") + ":</b> " + GUIUtil::HtmlEscape(merchant) + "<br>";
	}
	}

	if (wtx.IsCoinBase())
	{
	quint32 numBlocksToMaturity = COINBASE_MATURITY + 1;
	strHTML += "<br>" + tr("Generated coins must mature %1 blocks before they can be spent. When you generated this block, it was broadcast to the network to be added to the block chain. If it fails to get into the chain, its state will change to \"not accepted\" and it won't be spendable. This may occasionally happen if another node generates a block within a few seconds of yours.").arg(QString::number(numBlocksToMaturity)) + "<br>";
	}

	//
	// Debug view
	//
	if (fDebug)
	{
	strHTML += "<hr><br>" + tr("Debug information") + "<br><br>";
	BOOST_FOREACH(const CTxIn& txin, wtx.vin)
	if(wallet->IsMine(txin))
	- strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, -wallet->GetDebit(txin)) + "<br>";
	+ strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -wallet->GetDebit(txin)) + "<br>";
	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	if(wallet->IsMine(txout))
	- strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatWithUnit(unit, wallet->GetCredit(txout)) + "<br>";
	+ strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, wallet->GetCredit(txout)) + "<br>";

	strHTML += "<br><b>" + tr("Transaction") + ":</b><br>";
	strHTML += GUIUtil::HtmlEscape(wtx.ToString(), true);

	strHTML += "<br><b>" + tr("Inputs") + ":</b>";
	strHTML += "<ul>";

	BOOST_FOREACH(const CTxIn& txin, wtx.vin)
	{
	COutPoint prevout = txin.prevout;

	CCoins prev;
	if(pcoinsTip->GetCoins(prevout.hash, prev))
	{
	if (prevout.n < prev.vout.size())
	{
	strHTML += "<li>";
	const CTxOut &vout = prev.vout[prevout.n];
	CTxDestination address;
	if (ExtractDestination(vout.scriptPubKey, address))
	{
	if (wallet->mapAddressBook.count(address) && !wallet->mapAddressBook[address].name.empty())
	strHTML += GUIUtil::HtmlEscape(wallet->mapAddressBook[address].name) + " ";
	strHTML += QString::fromStdString(CBitcoinAddress(address).ToString());
	}
	- strHTML = strHTML + " " + tr("Amount") + "=" + BitcoinUnits::formatWithUnit(unit, vout.nValue);
	+ strHTML = strHTML + " " + tr("Amount") + "=" + BitcoinUnits::formatHtmlWithUnit(unit, vout.nValue);
	strHTML = strHTML + " IsMine=" + (wallet->IsMine(vout) ? tr("true") : tr("false")) + "</li>";
	}
	}
	}

	strHTML += "</ul>";
	}

	strHTML += "</font></html>";
	return strHTML;
	}
	diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp
	index 8cf2b0a1b..c0f7edd87 100644
	--- a/src/qt/transactiontablemodel.cpp
	+++ b/src/qt/transactiontablemodel.cpp
	@@ -1,628 +1,628 @@
	// Copyright (c) 2011-2014 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "transactiontablemodel.h"

	#include "addresstablemodel.h"
	-#include "bitcoinunits.h"
	#include "guiconstants.h"
	#include "guiutil.h"
	#include "optionsmodel.h"
	#include "transactiondesc.h"
	#include "transactionrecord.h"
	#include "walletmodel.h"

	#include "main.h"
	#include "sync.h"
	#include "uint256.h"
	#include "util.h"
	#include "wallet.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, /* 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:
	TransactionTablePriv(CWallet wallet, TransactionTableModel parent) :
	wallet(wallet),
	parent(parent)
	{
	}

	CWallet *wallet;
	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()
	{
	qDebug() << "TransactionTablePriv::refreshWallet";
	cachedWallet.clear();
	{
	LOCK2(cs_main, wallet->cs_wallet);
	for(std::map<uint256, CWalletTx>::iterator it = wallet->mapWallet.begin(); it != wallet->mapWallet.end(); ++it)
	{
	if(TransactionRecord::showTransaction(it->second))
	cachedWallet.append(TransactionRecord::decomposeTransaction(wallet, it->second));
	}
	}
	}

	/* 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(const uint256 &hash, int status)
	{
	qDebug() << "TransactionTablePriv::updateWallet : " + QString::fromStdString(hash.ToString()) + " " + QString::number(status);
	{
	LOCK2(cs_main, wallet->cs_wallet);

	// Find transaction in wallet
	std::map<uint256, CWalletTx>::iterator mi = wallet->mapWallet.find(hash);
	bool inWallet = mi != wallet->mapWallet.end();

	// 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);

	// Determine whether to show transaction or not
	bool showTransaction = (inWallet && TransactionRecord::showTransaction(mi->second));

	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() << " inWallet=" + QString::number(inWallet) + " 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)
	{
	qDebug() << "TransactionTablePriv::updateWallet : Warning: Got CT_NEW, but transaction is already in model";
	break;
	}
	if(!inWallet)
	{
	qDebug() << "TransactionTablePriv::updateWallet : Warning: Got CT_NEW, but transaction is not in wallet";
	break;
	}
	if(showTransaction)
	{
	// Added -- insert at the right position
	QList<TransactionRecord> toInsert =
	TransactionRecord::decomposeTransaction(wallet, mi->second);
	if(!toInsert.isEmpty()) /* only if something to insert */
	{
	parent->beginInsertRows(QModelIndex(), lowerIndex, lowerIndex+toInsert.size()-1);
	int insert_idx = lowerIndex;
	foreach(const TransactionRecord &rec, toInsert)
	{
	cachedWallet.insert(insert_idx, rec);
	insert_idx += 1;
	}
	parent->endInsertRows();
	}
	}
	break;
	case CT_DELETED:
	if(!inModel)
	{
	qDebug() << "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.
	break;
	}
	}
	}

	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;
	}
	else
	{
	return 0;
	}
	}

	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->idx, unit);
	}
	}
	return QString("");
	}
	};

	TransactionTableModel::TransactionTableModel(CWallet* wallet, WalletModel *parent):
	QAbstractTableModel(parent),
	wallet(wallet),
	walletModel(parent),
	priv(new TransactionTablePriv(wallet, this))
	{
	columns << QString() << tr("Date") << tr("Type") << tr("Address") << tr("Amount");

	priv->refreshWallet();

	connect(walletModel->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));
	}

	TransactionTableModel::~TransactionTableModel()
	{
	delete priv;
	}

	void TransactionTableModel::updateTransaction(const QString &hash, int status)
	{
	uint256 updated;
	updated.SetHex(hash.toStdString());

	priv->updateWallet(updated, status);
	}

	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));
	}

	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::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;
	}

	return status;
	}

	QString TransactionTableModel::formatTxDate(const TransactionRecord *wtx) const
	{
	if(wtx->time)
	{
	return GUIUtil::dateTimeStr(wtx->time);
	}
	else
	{
	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 + QString(" ");
	}
	if(label.isEmpty() \|\| walletModel->getOptionsModel()->getDisplayAddresses() \|\| 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");
	}
	return QVariant();
	}

	QString TransactionTableModel::formatTxToAddress(const TransactionRecord *wtx, bool tooltip) const
	{
	switch(wtx->type)
	{
	case TransactionRecord::RecvFromOther:
	return QString::fromStdString(wtx->address);
	case TransactionRecord::RecvWithAddress:
	case TransactionRecord::SendToAddress:
	case TransactionRecord::Generated:
	return lookupAddress(wtx->address, tooltip);
	case TransactionRecord::SendToOther:
	return QString::fromStdString(wtx->address);
	case TransactionRecord::SendToSelf:
	default:
	return tr("(n/a)");
	}
	}

	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) const
	+QString TransactionTableModel::formatTxAmount(const TransactionRecord *wtx, bool showUnconfirmed, BitcoinUnits::SeparatorStyle separators, bool fAlign) const
	{
	- QString str = BitcoinUnits::format(walletModel->getOptionsModel()->getDisplayUnit(), wtx->credit + wtx->debit);
	+ QString str = BitcoinUnits::format(walletModel->getOptionsModel()->getDisplayUnit(), wtx->credit + wtx->debit, false, separators, fAlign);
	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 QColor(64,64,255);
	case TransactionStatus::Offline:
	return QColor(192,192,192);
	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");
	}
	return QColor(0,0,0);
	}

	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 Qt::DecorationRole:
	switch(index.column())
	{
	case Status:
	return txStatusDecoration(rec);
	case ToAddress:
	return txAddressDecoration(rec);
	}
	break;
	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);
	+ return formatTxAmount(rec, true, BitcoinUnits::separatorAlways, true);
	}
	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 ToAddress:
	return formatTxToAddress(rec, true);
	case Amount:
	return rec->credit + rec->debit;
	}
	break;
	case Qt::ToolTipRole:
	return formatTooltip(rec);
	case Qt::TextAlignmentRole:
	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)
	{
	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 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:
	return 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:
	- return formatTxAmount(rec, false);
	+ // 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 ToAddress:
	return tr("Destination address of 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(row);
	if(data)
	{
	return createIndex(row, column, priv->index(row));
	}
	else
	{
	return QModelIndex();
	}
	}

	void TransactionTableModel::updateDisplayUnit()
	{
	// emit dataChanged to update Amount column with the current unit
	emit dataChanged(index(0, Amount), index(priv->size()-1, Amount));
	}
	diff --git a/src/qt/transactiontablemodel.h b/src/qt/transactiontablemodel.h
	index 333e6bc6e..9ee375d78 100644
	--- a/src/qt/transactiontablemodel.h
	+++ b/src/qt/transactiontablemodel.h
	@@ -1,94 +1,96 @@
	// Copyright (c) 2011-2013 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef TRANSACTIONTABLEMODEL_H
	#define TRANSACTIONTABLEMODEL_H

	#include <QAbstractTableModel>
	#include <QStringList>

	+#include "bitcoinunits.h"
	+
	class TransactionRecord;
	class TransactionTablePriv;
	class WalletModel;

	class CWallet;

	/** UI model for the transaction table of a wallet.
	*/
	class TransactionTableModel : public QAbstractTableModel
	{
	Q_OBJECT

	public:
	explicit TransactionTableModel(CWallet* wallet, WalletModel *parent = 0);
	~TransactionTableModel();

	enum ColumnIndex {
	Status = 0,
	Date = 1,
	Type = 2,
	ToAddress = 3,
	Amount = 4
	};

	/** Roles to get specific information from a transaction row.
	These are independent of column.
	*/
	enum RoleIndex {
	/** Type of transaction */
	TypeRole = Qt::UserRole,
	/** Date and time this transaction was created */
	DateRole,
	/** Long description (HTML format) */
	LongDescriptionRole,
	/** Address of transaction */
	AddressRole,
	/** Label of address related to transaction */
	LabelRole,
	/** Net amount of transaction */
	AmountRole,
	/** Unique identifier */
	TxIDRole,
	/** Transaction hash */
	TxHashRole,
	/** Is transaction confirmed? */
	ConfirmedRole,
	/** Formatted amount, without brackets when unconfirmed */
	FormattedAmountRole,
	/** Transaction status (TransactionRecord::Status) */
	StatusRole
	};

	int rowCount(const QModelIndex &parent) const;
	int columnCount(const QModelIndex &parent) const;
	QVariant data(const QModelIndex &index, int role) const;
	QVariant headerData(int section, Qt::Orientation orientation, int role) const;
	QModelIndex index(int row, int column, const QModelIndex & parent = QModelIndex()) const;

	private:
	CWallet* wallet;
	WalletModel *walletModel;
	QStringList columns;
	TransactionTablePriv *priv;

	QString lookupAddress(const std::string &address, bool tooltip) const;
	QVariant addressColor(const TransactionRecord *wtx) const;
	QString formatTxStatus(const TransactionRecord *wtx) const;
	QString formatTxDate(const TransactionRecord *wtx) const;
	QString formatTxType(const TransactionRecord *wtx) const;
	QString formatTxToAddress(const TransactionRecord *wtx, bool tooltip) const;
	- QString formatTxAmount(const TransactionRecord *wtx, bool showUnconfirmed=true) const;
	+ QString formatTxAmount(const TransactionRecord *wtx, bool showUnconfirmed=true, BitcoinUnits::SeparatorStyle separators=BitcoinUnits::separatorStandard, bool fAlign=false) const;
	QString formatTooltip(const TransactionRecord *rec) const;
	QVariant txStatusDecoration(const TransactionRecord *wtx) const;
	QVariant txAddressDecoration(const TransactionRecord *wtx) const;

	public slots:
	void updateTransaction(const QString &hash, int status);
	void updateConfirmations();
	void updateDisplayUnit();

	friend class TransactionTablePriv;
	};

	#endif // TRANSACTIONTABLEMODEL_H
	diff --git a/src/qt/transactionview.cpp b/src/qt/transactionview.cpp
	index d4d29416c..98914fc2d 100644
	--- a/src/qt/transactionview.cpp
	+++ b/src/qt/transactionview.cpp
	@@ -1,482 +1,503 @@
	// Copyright (c) 2011-2013 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include "transactionview.h"

	#include "addresstablemodel.h"
	#include "bitcoinunits.h"
	#include "csvmodelwriter.h"
	#include "editaddressdialog.h"
	#include "guiutil.h"
	#include "optionsmodel.h"
	#include "transactiondescdialog.h"
	#include "transactionfilterproxy.h"
	#include "transactionrecord.h"
	#include "transactiontablemodel.h"
	#include "walletmodel.h"

	#include "ui_interface.h"

	#include <QComboBox>
	#include <QDateTimeEdit>
	#include <QDesktopServices>
	#include <QDoubleValidator>
	#include <QHBoxLayout>
	#include <QHeaderView>
	#include <QLabel>
	#include <QLineEdit>
	#include <QMenu>
	#include <QPoint>
	#include <QScrollBar>
	#include <QSignalMapper>
	#include <QTableView>
	#include <QUrl>
	#include <QVBoxLayout>

	TransactionView::TransactionView(QWidget *parent) :
	QWidget(parent), model(0), transactionProxyModel(0),
	transactionView(0)
	{
	// Build filter row
	setContentsMargins(0,0,0,0);

	QHBoxLayout *hlayout = new QHBoxLayout();
	hlayout->setContentsMargins(0,0,0,0);
	#ifdef Q_OS_MAC
	hlayout->setSpacing(5);
	hlayout->addSpacing(26);
	#else
	hlayout->setSpacing(0);
	hlayout->addSpacing(23);
	#endif

	dateWidget = new QComboBox(this);
	#ifdef Q_OS_MAC
	dateWidget->setFixedWidth(121);
	#else
	dateWidget->setFixedWidth(120);
	#endif
	dateWidget->addItem(tr("All"), All);
	dateWidget->addItem(tr("Today"), Today);
	dateWidget->addItem(tr("This week"), ThisWeek);
	dateWidget->addItem(tr("This month"), ThisMonth);
	dateWidget->addItem(tr("Last month"), LastMonth);
	dateWidget->addItem(tr("This year"), ThisYear);
	dateWidget->addItem(tr("Range..."), Range);
	hlayout->addWidget(dateWidget);

	typeWidget = new QComboBox(this);
	#ifdef Q_OS_MAC
	typeWidget->setFixedWidth(121);
	#else
	typeWidget->setFixedWidth(120);
	#endif

	typeWidget->addItem(tr("All"), TransactionFilterProxy::ALL_TYPES);
	typeWidget->addItem(tr("Received with"), TransactionFilterProxy::TYPE(TransactionRecord::RecvWithAddress) \|
	TransactionFilterProxy::TYPE(TransactionRecord::RecvFromOther));
	typeWidget->addItem(tr("Sent to"), TransactionFilterProxy::TYPE(TransactionRecord::SendToAddress) \|
	TransactionFilterProxy::TYPE(TransactionRecord::SendToOther));
	typeWidget->addItem(tr("To yourself"), TransactionFilterProxy::TYPE(TransactionRecord::SendToSelf));
	typeWidget->addItem(tr("Mined"), TransactionFilterProxy::TYPE(TransactionRecord::Generated));
	typeWidget->addItem(tr("Other"), TransactionFilterProxy::TYPE(TransactionRecord::Other));

	hlayout->addWidget(typeWidget);

	addressWidget = new QLineEdit(this);
	#if QT_VERSION >= 0x040700
	addressWidget->setPlaceholderText(tr("Enter address or label to search"));
	#endif
	hlayout->addWidget(addressWidget);

	amountWidget = new QLineEdit(this);
	#if QT_VERSION >= 0x040700
	amountWidget->setPlaceholderText(tr("Min amount"));
	#endif
	#ifdef Q_OS_MAC
	amountWidget->setFixedWidth(97);
	#else
	amountWidget->setFixedWidth(100);
	#endif
	amountWidget->setValidator(new QDoubleValidator(0, 1e20, 8, this));
	hlayout->addWidget(amountWidget);

	QVBoxLayout *vlayout = new QVBoxLayout(this);
	vlayout->setContentsMargins(0,0,0,0);
	vlayout->setSpacing(0);

	QTableView *view = new QTableView(this);
	vlayout->addLayout(hlayout);
	vlayout->addWidget(createDateRangeWidget());
	vlayout->addWidget(view);
	vlayout->setSpacing(0);
	int width = view->verticalScrollBar()->sizeHint().width();
	// Cover scroll bar width with spacing
	#ifdef Q_OS_MAC
	hlayout->addSpacing(width+2);
	#else
	hlayout->addSpacing(width);
	#endif
	// Always show scroll bar
	view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
	view->setTabKeyNavigation(false);
	view->setContextMenuPolicy(Qt::CustomContextMenu);

	+ view->installEventFilter(this);
	+
	transactionView = view;

	// Actions
	QAction *copyAddressAction = new QAction(tr("Copy address"), this);
	QAction *copyLabelAction = new QAction(tr("Copy label"), this);
	QAction *copyAmountAction = new QAction(tr("Copy amount"), this);
	QAction *copyTxIDAction = new QAction(tr("Copy transaction ID"), this);
	QAction *editLabelAction = new QAction(tr("Edit label"), this);
	QAction *showDetailsAction = new QAction(tr("Show transaction details"), this);

	contextMenu = new QMenu();
	contextMenu->addAction(copyAddressAction);
	contextMenu->addAction(copyLabelAction);
	contextMenu->addAction(copyAmountAction);
	contextMenu->addAction(copyTxIDAction);
	contextMenu->addAction(editLabelAction);
	contextMenu->addAction(showDetailsAction);

	mapperThirdPartyTxUrls = new QSignalMapper(this);

	// Connect actions
	connect(mapperThirdPartyTxUrls, SIGNAL(mapped(QString)), this, SLOT(openThirdPartyTxUrl(QString)));

	connect(dateWidget, SIGNAL(activated(int)), this, SLOT(chooseDate(int)));
	connect(typeWidget, SIGNAL(activated(int)), this, SLOT(chooseType(int)));
	connect(addressWidget, SIGNAL(textChanged(QString)), this, SLOT(changedPrefix(QString)));
	connect(amountWidget, SIGNAL(textChanged(QString)), this, SLOT(changedAmount(QString)));

	connect(view, SIGNAL(doubleClicked(QModelIndex)), this, SIGNAL(doubleClicked(QModelIndex)));
	connect(view, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(contextualMenu(QPoint)));

	connect(copyAddressAction, SIGNAL(triggered()), this, SLOT(copyAddress()));
	connect(copyLabelAction, SIGNAL(triggered()), this, SLOT(copyLabel()));
	connect(copyAmountAction, SIGNAL(triggered()), this, SLOT(copyAmount()));
	connect(copyTxIDAction, SIGNAL(triggered()), this, SLOT(copyTxID()));
	connect(editLabelAction, SIGNAL(triggered()), this, SLOT(editLabel()));
	connect(showDetailsAction, SIGNAL(triggered()), this, SLOT(showDetails()));
	}

	void TransactionView::setModel(WalletModel *model)
	{
	this->model = model;
	if(model)
	{
	transactionProxyModel = new TransactionFilterProxy(this);
	transactionProxyModel->setSourceModel(model->getTransactionTableModel());
	transactionProxyModel->setDynamicSortFilter(true);
	transactionProxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
	transactionProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);

	transactionProxyModel->setSortRole(Qt::EditRole);

	transactionView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	transactionView->setModel(transactionProxyModel);
	transactionView->setAlternatingRowColors(true);
	transactionView->setSelectionBehavior(QAbstractItemView::SelectRows);
	transactionView->setSelectionMode(QAbstractItemView::ExtendedSelection);
	transactionView->setSortingEnabled(true);
	transactionView->sortByColumn(TransactionTableModel::Status, Qt::DescendingOrder);
	transactionView->verticalHeader()->hide();

	transactionView->setColumnWidth(TransactionTableModel::Status, STATUS_COLUMN_WIDTH);
	transactionView->setColumnWidth(TransactionTableModel::Date, DATE_COLUMN_WIDTH);
	transactionView->setColumnWidth(TransactionTableModel::Type, TYPE_COLUMN_WIDTH);
	transactionView->setColumnWidth(TransactionTableModel::Amount, AMOUNT_MINIMUM_COLUMN_WIDTH);

	columnResizingFixer = new GUIUtil::TableViewLastColumnResizingFixer(transactionView, AMOUNT_MINIMUM_COLUMN_WIDTH, MINIMUM_COLUMN_WIDTH);

	if (model->getOptionsModel())
	{
	// Add third party transaction URLs to context menu
	QStringList listUrls = model->getOptionsModel()->getThirdPartyTxUrls().split("\|", QString::SkipEmptyParts);
	for (int i = 0; i < listUrls.size(); ++i)
	{
	QString host = QUrl(listUrls[i].trimmed(), QUrl::StrictMode).host();
	if (!host.isEmpty())
	{
	QAction *thirdPartyTxUrlAction = new QAction(host, this); // use host as menu item label
	if (i == 0)
	contextMenu->addSeparator();
	contextMenu->addAction(thirdPartyTxUrlAction);
	connect(thirdPartyTxUrlAction, SIGNAL(triggered()), mapperThirdPartyTxUrls, SLOT(map()));
	mapperThirdPartyTxUrls->setMapping(thirdPartyTxUrlAction, listUrls[i].trimmed());
	}
	}
	}
	}
	}

	void TransactionView::chooseDate(int idx)
	{
	if(!transactionProxyModel)
	return;
	QDate current = QDate::currentDate();
	dateRangeWidget->setVisible(false);
	switch(dateWidget->itemData(idx).toInt())
	{
	case All:
	transactionProxyModel->setDateRange(
	TransactionFilterProxy::MIN_DATE,
	TransactionFilterProxy::MAX_DATE);
	break;
	case Today:
	transactionProxyModel->setDateRange(
	QDateTime(current),
	TransactionFilterProxy::MAX_DATE);
	break;
	case ThisWeek: {
	// Find last Monday
	QDate startOfWeek = current.addDays(-(current.dayOfWeek()-1));
	transactionProxyModel->setDateRange(
	QDateTime(startOfWeek),
	TransactionFilterProxy::MAX_DATE);

	} break;
	case ThisMonth:
	transactionProxyModel->setDateRange(
	QDateTime(QDate(current.year(), current.month(), 1)),
	TransactionFilterProxy::MAX_DATE);
	break;
	case LastMonth:
	transactionProxyModel->setDateRange(
	QDateTime(QDate(current.year(), current.month()-1, 1)),
	QDateTime(QDate(current.year(), current.month(), 1)));
	break;
	case ThisYear:
	transactionProxyModel->setDateRange(
	QDateTime(QDate(current.year(), 1, 1)),
	TransactionFilterProxy::MAX_DATE);
	break;
	case Range:
	dateRangeWidget->setVisible(true);
	dateRangeChanged();
	break;
	}
	}

	void TransactionView::chooseType(int idx)
	{
	if(!transactionProxyModel)
	return;
	transactionProxyModel->setTypeFilter(
	typeWidget->itemData(idx).toInt());
	}

	void TransactionView::changedPrefix(const QString &prefix)
	{
	if(!transactionProxyModel)
	return;
	transactionProxyModel->setAddressPrefix(prefix);
	}

	void TransactionView::changedAmount(const QString &amount)
	{
	if(!transactionProxyModel)
	return;
	qint64 amount_parsed = 0;
	if(BitcoinUnits::parse(model->getOptionsModel()->getDisplayUnit(), amount, &amount_parsed))
	{
	transactionProxyModel->setMinAmount(amount_parsed);
	}
	else
	{
	transactionProxyModel->setMinAmount(0);
	}
	}

	void TransactionView::exportClicked()
	{
	// CSV is currently the only supported format
	QString filename = GUIUtil::getSaveFileName(this,
	tr("Export Transaction History"), QString(),
	tr("Comma separated file (*.csv)"), NULL);

	if (filename.isNull())
	return;

	CSVModelWriter writer(filename);

	// name, column, role
	writer.setModel(transactionProxyModel);
	writer.addColumn(tr("Confirmed"), 0, TransactionTableModel::ConfirmedRole);
	writer.addColumn(tr("Date"), 0, TransactionTableModel::DateRole);
	writer.addColumn(tr("Type"), TransactionTableModel::Type, Qt::EditRole);
	writer.addColumn(tr("Label"), 0, TransactionTableModel::LabelRole);
	writer.addColumn(tr("Address"), 0, TransactionTableModel::AddressRole);
	writer.addColumn(tr("Amount"), 0, TransactionTableModel::FormattedAmountRole);
	writer.addColumn(tr("ID"), 0, TransactionTableModel::TxIDRole);

	if(!writer.write()) {
	emit message(tr("Exporting Failed"), tr("There was an error trying to save the transaction history to %1.").arg(filename),
	CClientUIInterface::MSG_ERROR);
	}
	else {
	emit message(tr("Exporting Successful"), tr("The transaction history was successfully saved to %1.").arg(filename),
	CClientUIInterface::MSG_INFORMATION);
	}
	}

	void TransactionView::contextualMenu(const QPoint &point)
	{
	QModelIndex index = transactionView->indexAt(point);
	if(index.isValid())
	{
	contextMenu->exec(QCursor::pos());
	}
	}

	void TransactionView::copyAddress()
	{
	GUIUtil::copyEntryData(transactionView, 0, TransactionTableModel::AddressRole);
	}

	void TransactionView::copyLabel()
	{
	GUIUtil::copyEntryData(transactionView, 0, TransactionTableModel::LabelRole);
	}

	void TransactionView::copyAmount()
	{
	GUIUtil::copyEntryData(transactionView, 0, TransactionTableModel::FormattedAmountRole);
	}

	void TransactionView::copyTxID()
	{
	GUIUtil::copyEntryData(transactionView, 0, TransactionTableModel::TxIDRole);
	}

	void TransactionView::editLabel()
	{
	if(!transactionView->selectionModel() \|\|!model)
	return;
	QModelIndexList selection = transactionView->selectionModel()->selectedRows();
	if(!selection.isEmpty())
	{
	AddressTableModel *addressBook = model->getAddressTableModel();
	if(!addressBook)
	return;
	QString address = selection.at(0).data(TransactionTableModel::AddressRole).toString();
	if(address.isEmpty())
	{
	// If this transaction has no associated address, exit
	return;
	}
	// Is address in address book? Address book can miss address when a transaction is
	// sent from outside the UI.
	int idx = addressBook->lookupAddress(address);
	if(idx != -1)
	{
	// Edit sending / receiving address
	QModelIndex modelIdx = addressBook->index(idx, 0, QModelIndex());
	// Determine type of address, launch appropriate editor dialog type
	QString type = modelIdx.data(AddressTableModel::TypeRole).toString();

	EditAddressDialog dlg(
	type == AddressTableModel::Receive
	? EditAddressDialog::EditReceivingAddress
	: EditAddressDialog::EditSendingAddress, this);
	dlg.setModel(addressBook);
	dlg.loadRow(idx);
	dlg.exec();
	}
	else
	{
	// Add sending address
	EditAddressDialog dlg(EditAddressDialog::NewSendingAddress,
	this);
	dlg.setModel(addressBook);
	dlg.setAddress(address);
	dlg.exec();
	}
	}
	}

	void TransactionView::showDetails()
	{
	if(!transactionView->selectionModel())
	return;
	QModelIndexList selection = transactionView->selectionModel()->selectedRows();
	if(!selection.isEmpty())
	{
	TransactionDescDialog dlg(selection.at(0));
	dlg.exec();
	}
	}

	void TransactionView::openThirdPartyTxUrl(QString url)
	{
	if(!transactionView \|\| !transactionView->selectionModel())
	return;
	QModelIndexList selection = transactionView->selectionModel()->selectedRows(0);
	if(!selection.isEmpty())
	QDesktopServices::openUrl(QUrl::fromUserInput(url.replace("%s", selection.at(0).data(TransactionTableModel::TxHashRole).toString())));
	}

	QWidget *TransactionView::createDateRangeWidget()
	{
	dateRangeWidget = new QFrame();
	dateRangeWidget->setFrameStyle(QFrame::Panel \| QFrame::Raised);
	dateRangeWidget->setContentsMargins(1,1,1,1);
	QHBoxLayout *layout = new QHBoxLayout(dateRangeWidget);
	layout->setContentsMargins(0,0,0,0);
	layout->addSpacing(23);
	layout->addWidget(new QLabel(tr("Range:")));

	dateFrom = new QDateTimeEdit(this);
	dateFrom->setDisplayFormat("dd/MM/yy");
	dateFrom->setCalendarPopup(true);
	dateFrom->setMinimumWidth(100);
	dateFrom->setDate(QDate::currentDate().addDays(-7));
	layout->addWidget(dateFrom);
	layout->addWidget(new QLabel(tr("to")));

	dateTo = new QDateTimeEdit(this);
	dateTo->setDisplayFormat("dd/MM/yy");
	dateTo->setCalendarPopup(true);
	dateTo->setMinimumWidth(100);
	dateTo->setDate(QDate::currentDate());
	layout->addWidget(dateTo);
	layout->addStretch();

	// Hide by default
	dateRangeWidget->setVisible(false);

	// Notify on change
	connect(dateFrom, SIGNAL(dateChanged(QDate)), this, SLOT(dateRangeChanged()));
	connect(dateTo, SIGNAL(dateChanged(QDate)), this, SLOT(dateRangeChanged()));

	return dateRangeWidget;
	}

	void TransactionView::dateRangeChanged()
	{
	if(!transactionProxyModel)
	return;
	transactionProxyModel->setDateRange(
	QDateTime(dateFrom->date()),
	QDateTime(dateTo->date()).addDays(1));
	}

	void TransactionView::focusTransaction(const QModelIndex &idx)
	{
	if(!transactionProxyModel)
	return;
	QModelIndex targetIdx = transactionProxyModel->mapFromSource(idx);
	transactionView->scrollTo(targetIdx);
	transactionView->setCurrentIndex(targetIdx);
	transactionView->setFocus();
	}

	// We override the virtual resizeEvent of the QWidget to adjust tables column
	// sizes as the tables width is proportional to the dialogs width.
	void TransactionView::resizeEvent(QResizeEvent* event)
	{
	QWidget::resizeEvent(event);
	columnResizingFixer->stretchColumnWidth(TransactionTableModel::ToAddress);
	}
	+
	+// Need to override default Ctrl+C action for amount as default behaviour is just to copy DisplayRole text
	+bool TransactionView::eventFilter(QObject obj, QEvent event)
	+{
	+ if (event->type() == QEvent::KeyPress)
	+ {
	+ QKeyEvent ke = static_cast<QKeyEvent >(event);
	+ if (ke->key() == Qt::Key_C && ke->modifiers().testFlag(Qt::ControlModifier))
	+ {
	+ QModelIndex i = this->transactionView->currentIndex();
	+ if (i.isValid() && i.column() == TransactionTableModel::Amount)
	+ {
	+ GUIUtil::setClipboard(i.data(TransactionTableModel::FormattedAmountRole).toString());
	+ return true;
	+ }
	+ }
	+ }
	+ return QWidget::eventFilter(obj, event);
	+}
	diff --git a/src/qt/transactionview.h b/src/qt/transactionview.h
	index 7a89fa11c..618efbc56 100644
	--- a/src/qt/transactionview.h
	+++ b/src/qt/transactionview.h
	@@ -1,108 +1,111 @@
	// Copyright (c) 2011-2013 The Bitcoin developers
	// Distributed under the MIT/X11 software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef TRANSACTIONVIEW_H
	#define TRANSACTIONVIEW_H

	#include "guiutil.h"

	#include <QWidget>
	+#include <QKeyEvent>

	class TransactionFilterProxy;
	class WalletModel;

	QT_BEGIN_NAMESPACE
	class QComboBox;
	class QDateTimeEdit;
	class QFrame;
	class QLineEdit;
	class QMenu;
	class QModelIndex;
	class QSignalMapper;
	class QTableView;
	QT_END_NAMESPACE

	/** Widget showing the transaction list for a wallet, including a filter row.
	Using the filter row, the user can view or export a subset of the transactions.
	*/
	class TransactionView : public QWidget
	{
	Q_OBJECT

	public:
	explicit TransactionView(QWidget *parent = 0);

	void setModel(WalletModel *model);

	// Date ranges for filter
	enum DateEnum
	{
	All,
	Today,
	ThisWeek,
	ThisMonth,
	LastMonth,
	ThisYear,
	Range
	};

	enum ColumnWidths {
	STATUS_COLUMN_WIDTH = 23,
	DATE_COLUMN_WIDTH = 120,
	TYPE_COLUMN_WIDTH = 120,
	AMOUNT_MINIMUM_COLUMN_WIDTH = 120,
	MINIMUM_COLUMN_WIDTH = 23
	};

	private:
	WalletModel *model;
	TransactionFilterProxy *transactionProxyModel;
	QTableView *transactionView;

	QComboBox *dateWidget;
	QComboBox *typeWidget;
	QLineEdit *addressWidget;
	QLineEdit *amountWidget;

	QMenu *contextMenu;
	QSignalMapper *mapperThirdPartyTxUrls;

	QFrame *dateRangeWidget;
	QDateTimeEdit *dateFrom;
	QDateTimeEdit *dateTo;

	QWidget *createDateRangeWidget();

	GUIUtil::TableViewLastColumnResizingFixer *columnResizingFixer;

	virtual void resizeEvent(QResizeEvent* event);

	+ bool eventFilter(QObject obj, QEvent event);
	+
	private slots:
	void contextualMenu(const QPoint &);
	void dateRangeChanged();
	void showDetails();
	void copyAddress();
	void editLabel();
	void copyLabel();
	void copyAmount();
	void copyTxID();
	void openThirdPartyTxUrl(QString url);

	signals:
	void doubleClicked(const QModelIndex&);

	/** Fired when a message should be reported to the user */
	void message(const QString &title, const QString &message, unsigned int style);

	public slots:
	void chooseDate(int idx);
	void chooseType(int idx);
	void changedPrefix(const QString &prefix);
	void changedAmount(const QString &amount);
	void exportClicked();
	void focusTransaction(const QModelIndex&);

	};

	#endif // TRANSACTIONVIEW_H

File Metadata

Mime Type: text/x-diff
Expires: Tue, May 13, 01:40 (1 d, 3 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5777030
Default Alt Text: (107 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions