No OneTemporary
Actions

Size

93 KB

Subscribers

None

View Options

	diff --git a/src/qt/forms/optionsdialog.ui b/src/qt/forms/optionsdialog.ui
	index 9fbc86518..0103842e0 100644
	--- a/src/qt/forms/optionsdialog.ui
	+++ b/src/qt/forms/optionsdialog.ui
	@@ -1,644 +1,668 @@
	<?xml version="1.0" encoding="UTF-8"?>
	<ui version="4.0">
	<class>OptionsDialog</class>
	<widget class="QDialog" name="OptionsDialog">
	<property name="geometry">
	<rect>
	<x>0</x>
	<y>0</y>
	<width>560</width>
	<height>400</height>
	</rect>
	</property>
	<property name="windowTitle">
	<string>Options</string>
	</property>
	<property name="modal">
	<bool>true</bool>
	</property>
	<layout class="QVBoxLayout" name="verticalLayout">
	<item>
	<widget class="QTabWidget" name="tabWidget">
	<property name="currentIndex">
	<number>0</number>
	</property>
	<widget class="QWidget" name="tabMain">
	<attribute name="title">
	<string>&Main</string>
	</attribute>
	<layout class="QVBoxLayout" name="verticalLayout_Main">
	<item>
	<widget class="QCheckBox" name="bitcoinAtStartup">
	<property name="toolTip">
	<string>Automatically start Bitcoin after logging in to the system.</string>
	</property>
	<property name="text">
	<string>&Start Bitcoin on system login</string>
	</property>
	</widget>
	</item>
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_2_Main">
	<item>
	<widget class="QLabel" name="databaseCacheLabel">
	<property name="text">
	<string>Size of &database cache</string>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	<property name="buddy">
	<cstring>databaseCache</cstring>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QSpinBox" name="databaseCache"/>
	</item>
	<item>
	<widget class="QLabel" name="databaseCacheUnitLabel">
	<property name="text">
	<string>MB</string>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	</widget>
	</item>
	<item>
	<spacer name="horizontalSpacer_2_Main">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>40</width>
	<height>20</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</item>
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_3_Main">
	<item>
	<widget class="QLabel" name="threadsScriptVerifLabel">
	<property name="text">
	<string>Number of script &verification threads</string>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	<property name="buddy">
	<cstring>threadsScriptVerif</cstring>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QSpinBox" name="threadsScriptVerif">
	<property name="toolTip">
	<string>(0 = auto, <0 = leave that many cores free)</string>
	</property>
	</widget>
	</item>
	<item>
	<spacer name="horizontalSpacer_3_Main">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>40</width>
	<height>20</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</item>
	<item>
	<spacer name="verticalSpacer_Main">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>40</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</widget>
	<widget class="QWidget" name="tabWallet">
	<attribute name="title">
	<string>W&allet</string>
	</attribute>
	<layout class="QVBoxLayout" name="verticalLayout_Wallet">
	<item>
	<widget class="QLabel" name="transactionFeeInfoLabel">
	<property name="text">
	<string>Optional transaction fee per kB that helps make sure your transactions are processed quickly. Most transactions are 1 kB.</string>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	<property name="wordWrap">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_1_Wallet">
	<item>
	<widget class="QLabel" name="transactionFeeLabel">
	<property name="text">
	<string>Pay transaction &fee</string>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	<property name="buddy">
	<cstring>transactionFee</cstring>
	</property>
	</widget>
	</item>
	<item>
	<widget class="BitcoinAmountField" name="transactionFee"/>
	</item>
	<item>
	<spacer name="horizontalSpacer_1_Wallet">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>40</width>
	<height>20</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</item>
	<item>
	<spacer name="verticalSpacer_Wallet">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>40</height>
	</size>
	</property>
	</spacer>
	</item>
	<item>
	<widget class="QGroupBox" name="groupBox">
	<property name="title">
	<string>Expert</string>
	</property>
	<layout class="QVBoxLayout" name="verticalLayout_2">
	<item>
	<widget class="QCheckBox" name="coinControlFeatures">
	<property name="toolTip">
	<string>Whether to show coin control features or not.</string>
	</property>
	<property name="text">
	<string>Enable coin &control features</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QCheckBox" name="spendZeroConfChange">
	<property name="toolTip">
	<string>If you disable the spending of unconfirmed change, the change from a transaction cannot be used until that transaction has at least one confirmation. This also affects how your balance is computed.</string>
	</property>
	<property name="text">
	<string>&Spend unconfirmed change</string>
	</property>
	</widget>
	</item>
	</layout>
	</widget>
	</item>
	</layout>
	</widget>
	<widget class="QWidget" name="tabNetwork">
	<attribute name="title">
	<string>&Network</string>
	</attribute>
	<layout class="QVBoxLayout" name="verticalLayout_Network">
	<item>
	<widget class="QCheckBox" name="mapPortUpnp">
	<property name="toolTip">
	<string>Automatically open the Bitcoin client port on the router. This only works when your router supports UPnP and it is enabled.</string>
	</property>
	<property name="text">
	<string>Map port using &UPnP</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QCheckBox" name="connectSocks">
	<property name="toolTip">
	<string>Connect to the Bitcoin network through a SOCKS proxy.</string>
	</property>
	<property name="text">
	<string>&Connect through SOCKS proxy (default proxy):</string>
	</property>
	</widget>
	</item>
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_1_Network">
	<item>
	<widget class="QLabel" name="proxyIpLabel">
	<property name="text">
	<string>Proxy &IP:</string>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	<property name="buddy">
	<cstring>proxyIp</cstring>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QValidatedLineEdit" name="proxyIp">
	<property name="minimumSize">
	<size>
	<width>140</width>
	<height>0</height>
	</size>
	</property>
	<property name="maximumSize">
	<size>
	<width>140</width>
	<height>16777215</height>
	</size>
	</property>
	<property name="toolTip">
	<string>IP address of the proxy (e.g. IPv4: 127.0.0.1 / IPv6: ::1)</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QLabel" name="proxyPortLabel">
	<property name="text">
	<string>&Port:</string>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	<property name="buddy">
	<cstring>proxyPort</cstring>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QLineEdit" name="proxyPort">
	<property name="minimumSize">
	<size>
	<width>55</width>
	<height>0</height>
	</size>
	</property>
	<property name="maximumSize">
	<size>
	<width>55</width>
	<height>16777215</height>
	</size>
	</property>
	<property name="toolTip">
	<string>Port of the proxy (e.g. 9050)</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QLabel" name="socksVersionLabel">
	<property name="text">
	<string>SOCKS &Version:</string>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	<property name="buddy">
	<cstring>socksVersion</cstring>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QValueComboBox" name="socksVersion">
	<property name="toolTip">
	<string>SOCKS version of the proxy (e.g. 5)</string>
	</property>
	</widget>
	</item>
	<item>
	<spacer name="horizontalSpacer_1_Network">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>40</width>
	<height>20</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</item>
	<item>
	<spacer name="verticalSpacer_Network">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>40</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</widget>
	<widget class="QWidget" name="tabWindow">
	<attribute name="title">
	<string>&Window</string>
	</attribute>
	<layout class="QVBoxLayout" name="verticalLayout_Window">
	<item>
	<widget class="QCheckBox" name="minimizeToTray">
	<property name="toolTip">
	<string>Show only a tray icon after minimizing the window.</string>
	</property>
	<property name="text">
	<string>&Minimize to the tray instead of the taskbar</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QCheckBox" name="minimizeOnClose">
	<property name="toolTip">
	<string>Minimize instead of exit the application when the window is closed. When this option is enabled, the application will be closed only after selecting Quit in the menu.</string>
	</property>
	<property name="text">
	<string>M&inimize on close</string>
	</property>
	</widget>
	</item>
	<item>
	<spacer name="verticalSpacer_Window">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>40</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</widget>
	<widget class="QWidget" name="tabDisplay">
	<attribute name="title">
	<string>&Display</string>
	</attribute>
	<layout class="QVBoxLayout" name="verticalLayout_Display">
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_1_Display">
	<item>
	<widget class="QLabel" name="langLabel">
	<property name="text">
	<string>User Interface &language:</string>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	<property name="buddy">
	<cstring>lang</cstring>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QValueComboBox" name="lang">
	<property name="toolTip">
	<string>The user interface language can be set here. This setting will take effect after restarting Bitcoin.</string>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_2_Display">
	<item>
	<widget class="QLabel" name="unitLabel">
	<property name="text">
	<string>&Unit to show amounts in:</string>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	<property name="buddy">
	<cstring>unit</cstring>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QValueComboBox" name="unit">
	<property name="toolTip">
	<string>Choose the default subdivision unit to show in the interface and when sending coins.</string>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	<item>
	<widget class="QCheckBox" name="displayAddresses">
	<property name="toolTip">
	<string>Whether to show Bitcoin addresses in the transaction list or not.</string>
	</property>
	<property name="text">
	<string>&Display addresses in transaction list</string>
	</property>
	</widget>
	</item>
	+ <item>
	+ <layout class="QHBoxLayout" name="horizontalLayout_3_Display">
	+ <item>
	+ <widget class="QLabel" name="thirdPartyTxUrlsLabel">
	+ <property name="toolTip">
	+ <string>Third party URLs (e.g. a block explorer) that appear in the transactions tab as context menu items. %s in the URL is replaced by transaction hash. Multiple URLs are separated by vertical bar \|.</string>
	+ </property>
	+ <property name="text">
	+ <string>Third party transaction URLs</string>
	+ </property>
	+ <property name="buddy">
	+ <cstring>thirdPartyTxUrls</cstring>
	+ </property>
	+ </widget>
	+ </item>
	+ <item>
	+ <widget class="QLineEdit" name="thirdPartyTxUrls">
	+ <property name="toolTip">
	+ <string>Third party URLs (e.g. a block explorer) that appear in the transactions tab as context menu items. %s in the URL is replaced by transaction hash. Multiple URLs are separated by vertical bar \|.</string>
	+ </property>
	+ </widget>
	+ </item>
	+ </layout>
	+ </item>
	<item>
	<spacer name="verticalSpacer_Display">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>40</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</widget>
	</widget>
	</item>
	<item>
	<widget class="QFrame" name="frame">
	<layout class="QVBoxLayout" name="verticalLayout_Bottom">
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_Bottom">
	<item>
	<widget class="QLabel" name="overriddenByCommandLineInfoLabel">
	<property name="text">
	<string>Active command-line options that override above options:</string>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	</widget>
	</item>
	<item>
	<spacer name="horizontalSpacer_Bottom">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>40</width>
	<height>20</height>
	</size>
	</property>
	</spacer>
	</item>
	</layout>
	</item>
	<item>
	<widget class="QLabel" name="overriddenByCommandLineLabel">
	<property name="text">
	<string/>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	<property name="wordWrap">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	</layout>
	</widget>
	</item>
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_Buttons">
	<item>
	<widget class="QPushButton" name="resetButton">
	<property name="toolTip">
	<string>Reset all client options to default.</string>
	</property>
	<property name="text">
	<string>&Reset Options</string>
	</property>
	<property name="autoDefault">
	<bool>false</bool>
	</property>
	</widget>
	</item>
	<item>
	<spacer name="horizontalSpacer_1">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>40</width>
	<height>48</height>
	</size>
	</property>
	</spacer>
	</item>
	<item>
	<widget class="QLabel" name="statusLabel">
	<property name="minimumSize">
	<size>
	<width>200</width>
	<height>0</height>
	</size>
	</property>
	<property name="font">
	<font>
	<weight>75</weight>
	<bold>true</bold>
	</font>
	</property>
	<property name="text">
	<string/>
	</property>
	<property name="textFormat">
	<enum>Qt::PlainText</enum>
	</property>
	<property name="wordWrap">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item>
	<spacer name="horizontalSpacer_2">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>40</width>
	<height>48</height>
	</size>
	</property>
	</spacer>
	</item>
	<item>
	<widget class="QPushButton" name="okButton">
	<property name="text">
	<string>&OK</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QPushButton" name="cancelButton">
	<property name="text">
	<string>&Cancel</string>
	</property>
	<property name="autoDefault">
	<bool>false</bool>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	</layout>
	</widget>
	<customwidgets>
	<customwidget>
	<class>BitcoinAmountField</class>
	<extends>QLineEdit</extends>
	<header>bitcoinamountfield.h</header>
	<container>1</container>
	</customwidget>
	<customwidget>
	<class>QValidatedLineEdit</class>
	<extends>QLineEdit</extends>
	<header>qvalidatedlineedit.h</header>
	</customwidget>
	<customwidget>
	<class>QValueComboBox</class>
	<extends>QComboBox</extends>
	<header>qvaluecombobox.h</header>
	</customwidget>
	</customwidgets>
	<resources/>
	<connections/>
	</ui>
	diff --git a/src/qt/optionsdialog.cpp b/src/qt/optionsdialog.cpp
	index 394b5f3ae..96464d2cc 100644
	--- a/src/qt/optionsdialog.cpp
	+++ b/src/qt/optionsdialog.cpp
	@@ -1,297 +1,302 @@
	// 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.

	#if defined(HAVE_CONFIG_H)
	#include "bitcoin-config.h"
	#endif

	#include "optionsdialog.h"
	#include "ui_optionsdialog.h"

	#include "bitcoinunits.h"
	#include "guiutil.h"
	#include "monitoreddatamapper.h"
	#include "optionsmodel.h"

	#include "main.h" // for CTransaction::nMinTxFee and MAX_SCRIPTCHECK_THREADS
	#include "netbase.h"
	#include "txdb.h" // for -dbcache defaults

	#include <QDir>
	#include <QIntValidator>
	#include <QLocale>
	#include <QMessageBox>
	#include <QTimer>

	OptionsDialog::OptionsDialog(QWidget *parent) :
	QDialog(parent),
	ui(new Ui::OptionsDialog),
	model(0),
	mapper(0),
	fProxyIpValid(true)
	{
	ui->setupUi(this);
	GUIUtil::restoreWindowGeometry("nOptionsDialogWindow", this->size(), this);

	/* Main elements init */
	ui->databaseCache->setMinimum(nMinDbCache);
	ui->databaseCache->setMaximum(nMaxDbCache);
	ui->threadsScriptVerif->setMinimum(-(int)boost::thread::hardware_concurrency());
	ui->threadsScriptVerif->setMaximum(MAX_SCRIPTCHECK_THREADS);

	/* Network elements init */
	#ifndef USE_UPNP
	ui->mapPortUpnp->setEnabled(false);
	#endif

	ui->proxyIp->setEnabled(false);
	ui->proxyPort->setEnabled(false);
	ui->proxyPort->setValidator(new QIntValidator(1, 65535, this));

	/** SOCKS version is only selectable for default proxy and is always 5 for IPv6 and Tor */
	ui->socksVersion->setEnabled(false);
	ui->socksVersion->addItem("5", 5);
	ui->socksVersion->addItem("4", 4);
	ui->socksVersion->setCurrentIndex(0);

	connect(ui->connectSocks, SIGNAL(toggled(bool)), ui->proxyIp, SLOT(setEnabled(bool)));
	connect(ui->connectSocks, SIGNAL(toggled(bool)), ui->proxyPort, SLOT(setEnabled(bool)));
	connect(ui->connectSocks, SIGNAL(toggled(bool)), ui->socksVersion, SLOT(setEnabled(bool)));

	ui->proxyIp->installEventFilter(this);

	/* Window elements init */
	#ifdef Q_OS_MAC
	/* remove Window tab on Mac */
	ui->tabWidget->removeTab(ui->tabWidget->indexOf(ui->tabWindow));
	#endif

	/* Display elements init */
	QDir translations(":translations");
	ui->lang->addItem(QString("(") + tr("default") + QString(")"), QVariant(""));
	foreach(const QString &langStr, translations.entryList())
	{
	QLocale locale(langStr);

	/** check if the locale name consists of 2 parts (language_country) */
	if(langStr.contains("_"))
	{
	#if QT_VERSION >= 0x040800
	/** display language strings as "native language - native country (locale name)", e.g. "Deutsch - Deutschland (de)" */
	ui->lang->addItem(locale.nativeLanguageName() + QString(" - ") + locale.nativeCountryName() + QString(" (") + langStr + QString(")"), QVariant(langStr));
	#else
	/** display language strings as "language - country (locale name)", e.g. "German - Germany (de)" */
	ui->lang->addItem(QLocale::languageToString(locale.language()) + QString(" - ") + QLocale::countryToString(locale.country()) + QString(" (") + langStr + QString(")"), QVariant(langStr));
	#endif
	}
	else
	{
	#if QT_VERSION >= 0x040800
	/** display language strings as "native language (locale name)", e.g. "Deutsch (de)" */
	ui->lang->addItem(locale.nativeLanguageName() + QString(" (") + langStr + QString(")"), QVariant(langStr));
	#else
	/** display language strings as "language (locale name)", e.g. "German (de)" */
	ui->lang->addItem(QLocale::languageToString(locale.language()) + QString(" (") + langStr + QString(")"), QVariant(langStr));
	#endif
	}
	}
	+#if QT_VERSION >= 0x040700
	+ ui->thirdPartyTxUrls->setPlaceholderText("https://example.com/tx/%s");
	+#endif

	ui->unit->setModel(new BitcoinUnits(this));
	ui->transactionFee->setSingleStep(CTransaction::nMinTxFee);

	/* Widget-to-option mapper */
	mapper = new MonitoredDataMapper(this);
	mapper->setSubmitPolicy(QDataWidgetMapper::ManualSubmit);
	mapper->setOrientation(Qt::Vertical);

	/* setup/change UI elements when proxy IP is invalid/valid */
	connect(this, SIGNAL(proxyIpChecks(QValidatedLineEdit , int)), this, SLOT(doProxyIpChecks(QValidatedLineEdit , int)));
	}

	OptionsDialog::~OptionsDialog()
	{
	GUIUtil::saveWindowGeometry("nOptionsDialogWindow", this);
	delete ui;
	}

	void OptionsDialog::setModel(OptionsModel *model)
	{
	this->model = model;

	if(model)
	{
	/* check if client restart is needed and show persistent message */
	if (model->isRestartRequired())
	showRestartWarning(true);

	QString strLabel = model->getOverriddenByCommandLine();
	if (strLabel.isEmpty())
	strLabel = tr("none");
	ui->overriddenByCommandLineLabel->setText(strLabel);

	connect(model, SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));

	mapper->setModel(model);
	setMapper();
	mapper->toFirst();
	}

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

	/* warn when one of the following settings changes by user action (placed here so init via mapper doesn't trigger them) */

	/* Main */
	connect(ui->databaseCache, SIGNAL(valueChanged(int)), this, SLOT(showRestartWarning()));
	connect(ui->threadsScriptVerif, SIGNAL(valueChanged(int)), this, SLOT(showRestartWarning()));
	/* Wallet */
	connect(ui->spendZeroConfChange, SIGNAL(clicked(bool)), this, SLOT(showRestartWarning()));
	/* Network */
	connect(ui->connectSocks, SIGNAL(clicked(bool)), this, SLOT(showRestartWarning()));
	/* Display */
	connect(ui->lang, SIGNAL(valueChanged()), this, SLOT(showRestartWarning()));
	+ connect(ui->thirdPartyTxUrls, SIGNAL(textChanged(const QString &)), this, SLOT(showRestartWarning()));
	}

	void OptionsDialog::setMapper()
	{
	/* Main */
	mapper->addMapping(ui->bitcoinAtStartup, OptionsModel::StartAtStartup);
	mapper->addMapping(ui->threadsScriptVerif, OptionsModel::ThreadsScriptVerif);
	mapper->addMapping(ui->databaseCache, OptionsModel::DatabaseCache);

	/* Wallet */
	mapper->addMapping(ui->transactionFee, OptionsModel::Fee);
	mapper->addMapping(ui->spendZeroConfChange, OptionsModel::SpendZeroConfChange);
	mapper->addMapping(ui->coinControlFeatures, OptionsModel::CoinControlFeatures);

	/* Network */
	mapper->addMapping(ui->mapPortUpnp, OptionsModel::MapPortUPnP);

	mapper->addMapping(ui->connectSocks, OptionsModel::ProxyUse);
	mapper->addMapping(ui->proxyIp, OptionsModel::ProxyIP);
	mapper->addMapping(ui->proxyPort, OptionsModel::ProxyPort);
	mapper->addMapping(ui->socksVersion, OptionsModel::ProxySocksVersion);

	/* Window */
	#ifndef Q_OS_MAC
	mapper->addMapping(ui->minimizeToTray, OptionsModel::MinimizeToTray);
	mapper->addMapping(ui->minimizeOnClose, OptionsModel::MinimizeOnClose);
	#endif

	/* Display */
	mapper->addMapping(ui->lang, OptionsModel::Language);
	mapper->addMapping(ui->unit, OptionsModel::DisplayUnit);
	mapper->addMapping(ui->displayAddresses, OptionsModel::DisplayAddresses);
	+ mapper->addMapping(ui->thirdPartyTxUrls, OptionsModel::ThirdPartyTxUrls);
	}

	void OptionsDialog::enableOkButton()
	{
	/* prevent enabling of the OK button when data modified, if there is an invalid proxy address present */
	if(fProxyIpValid)
	setOkButtonState(true);
	}

	void OptionsDialog::disableOkButton()
	{
	setOkButtonState(false);
	}

	void OptionsDialog::setOkButtonState(bool fState)
	{
	ui->okButton->setEnabled(fState);
	}

	void OptionsDialog::on_resetButton_clicked()
	{
	if(model)
	{
	// confirmation dialog
	QMessageBox::StandardButton btnRetVal = QMessageBox::question(this, tr("Confirm options reset"),
	tr("Client restart required to activate changes.") + "<br><br>" + tr("Client will be shutdown, do you want to proceed?"),
	QMessageBox::Yes \| QMessageBox::Cancel, QMessageBox::Cancel);

	if(btnRetVal == QMessageBox::Cancel)
	return;

	/* reset all options and close GUI */
	model->Reset();
	QApplication::quit();
	}
	}

	void OptionsDialog::on_okButton_clicked()
	{
	mapper->submit();
	accept();
	}

	void OptionsDialog::on_cancelButton_clicked()
	{
	reject();
	}

	void OptionsDialog::showRestartWarning(bool fPersistent)
	{
	ui->statusLabel->setStyleSheet("QLabel { color: red; }");

	if(fPersistent)
	{
	ui->statusLabel->setText(tr("Client restart required to activate changes."));
	}
	else
	{
	ui->statusLabel->setText(tr("This change would require a client restart."));
	// clear non-persistent status label after 10 seconds
	// Todo: should perhaps be a class attribute, if we extend the use of statusLabel
	QTimer::singleShot(10000, this, SLOT(clearStatusLabel()));
	}
	}

	void OptionsDialog::clearStatusLabel()
	{
	ui->statusLabel->clear();
	}

	void OptionsDialog::updateDisplayUnit()
	{
	if(model)
	{
	/* Update transactionFee with the current unit */
	ui->transactionFee->setDisplayUnit(model->getDisplayUnit());
	}
	}

	void OptionsDialog::doProxyIpChecks(QValidatedLineEdit *pUiProxyIp, int nProxyPort)
	{
	Q_UNUSED(nProxyPort);

	const std::string strAddrProxy = pUiProxyIp->text().toStdString();
	CService addrProxy;

	/* Check for a valid IPv4 / IPv6 address */
	if (!(fProxyIpValid = LookupNumeric(strAddrProxy.c_str(), addrProxy)))
	{
	disableOkButton();
	pUiProxyIp->setValid(false);
	ui->statusLabel->setStyleSheet("QLabel { color: red; }");
	ui->statusLabel->setText(tr("The supplied proxy address is invalid."));
	}
	else
	{
	enableOkButton();
	ui->statusLabel->clear();
	}
	}

	bool OptionsDialog::eventFilter(QObject object, QEvent event)
	{
	if(event->type() == QEvent::FocusOut)
	{
	if(object == ui->proxyIp)
	{
	emit proxyIpChecks(ui->proxyIp, ui->proxyPort->text().toInt());
	}
	}
	return QDialog::eventFilter(object, event);
	}
	diff --git a/src/qt/optionsmodel.cpp b/src/qt/optionsmodel.cpp
	index 9abe9351b..74c6b10ce 100644
	--- a/src/qt/optionsmodel.cpp
	+++ b/src/qt/optionsmodel.cpp
	@@ -1,371 +1,384 @@
	// 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.

	#if defined(HAVE_CONFIG_H)
	#include "bitcoin-config.h"
	#endif

	#include "optionsmodel.h"

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

	#include "init.h"
	#include "main.h"
	#include "net.h"
	#include "txdb.h" // for -dbcache defaults
	#ifdef ENABLE_WALLET
	#include "wallet.h"
	#include "walletdb.h"
	#endif

	#include <QNetworkProxy>
	#include <QSettings>
	#include <QStringList>

	OptionsModel::OptionsModel(QObject *parent) :
	QAbstractListModel(parent)
	{
	Init();
	}

	void OptionsModel::addOverriddenOption(const std::string &option)
	{
	strOverriddenByCommandLine += QString::fromStdString(option) + "=" + QString::fromStdString(mapArgs[option]) + " ";
	}

	// Writes all missing QSettings with their default values
	void OptionsModel::Init()
	{
	QSettings settings;

	// Ensure restart flag is unset on client startup
	setRestartRequired(false);

	// These are Qt-only settings:

	// Window
	if (!settings.contains("fMinimizeToTray"))
	settings.setValue("fMinimizeToTray", false);
	fMinimizeToTray = settings.value("fMinimizeToTray").toBool();

	if (!settings.contains("fMinimizeOnClose"))
	settings.setValue("fMinimizeOnClose", false);
	fMinimizeOnClose = settings.value("fMinimizeOnClose").toBool();

	// Display
	if (!settings.contains("nDisplayUnit"))
	settings.setValue("nDisplayUnit", BitcoinUnits::BTC);
	nDisplayUnit = settings.value("nDisplayUnit").toInt();

	if (!settings.contains("bDisplayAddresses"))
	settings.setValue("bDisplayAddresses", false);
	bDisplayAddresses = settings.value("bDisplayAddresses", false).toBool();

	+ if (!settings.contains("strThirdPartyTxUrls"))
	+ settings.setValue("strThirdPartyTxUrls", "");
	+ strThirdPartyTxUrls = settings.value("strThirdPartyTxUrls", "").toString();
	+
	if (!settings.contains("fCoinControlFeatures"))
	settings.setValue("fCoinControlFeatures", false);
	fCoinControlFeatures = settings.value("fCoinControlFeatures", false).toBool();

	// These are shared with the core or have a command-line parameter
	// and we want command-line parameters to overwrite the GUI settings.
	//
	// If setting doesn't exist create it with defaults.
	//
	// If SoftSetArg() or SoftSetBoolArg() return false we were overridden
	// by command-line and show this in the UI.

	// Main
	if (!settings.contains("nDatabaseCache"))
	settings.setValue("nDatabaseCache", (qint64)nDefaultDbCache);
	if (!SoftSetArg("-dbcache", settings.value("nDatabaseCache").toString().toStdString()))
	addOverriddenOption("-dbcache");

	if (!settings.contains("nThreadsScriptVerif"))
	settings.setValue("nThreadsScriptVerif", DEFAULT_SCRIPTCHECK_THREADS);
	if (!SoftSetArg("-par", settings.value("nThreadsScriptVerif").toString().toStdString()))
	addOverriddenOption("-par");

	// Wallet
	#ifdef ENABLE_WALLET
	if (!settings.contains("nTransactionFee"))
	settings.setValue("nTransactionFee", 0);
	nTransactionFee = settings.value("nTransactionFee").toLongLong(); // if -paytxfee is set, this will be overridden later in init.cpp
	if (mapArgs.count("-paytxfee"))
	addOverriddenOption("-paytxfee");

	if (!settings.contains("bSpendZeroConfChange"))
	settings.setValue("bSpendZeroConfChange", true);
	if (!SoftSetBoolArg("-spendzeroconfchange", settings.value("bSpendZeroConfChange").toBool()))
	addOverriddenOption("-spendzeroconfchange");
	#endif

	// Network
	if (!settings.contains("fUseUPnP"))
	#ifdef USE_UPNP
	settings.setValue("fUseUPnP", true);
	#else
	settings.setValue("fUseUPnP", false);
	#endif
	if (!SoftSetBoolArg("-upnp", settings.value("fUseUPnP").toBool()))
	addOverriddenOption("-upnp");

	if (!settings.contains("fUseProxy"))
	settings.setValue("fUseProxy", false);
	if (!settings.contains("addrProxy"))
	settings.setValue("addrProxy", "127.0.0.1:9050");
	// Only try to set -proxy, if user has enabled fUseProxy
	if (settings.value("fUseProxy").toBool() && !SoftSetArg("-proxy", settings.value("addrProxy").toString().toStdString()))
	addOverriddenOption("-proxy");
	if (!settings.contains("nSocksVersion"))
	settings.setValue("nSocksVersion", 5);
	// Only try to set -socks, if user has enabled fUseProxy
	if (settings.value("fUseProxy").toBool() && !SoftSetArg("-socks", settings.value("nSocksVersion").toString().toStdString()))
	addOverriddenOption("-socks");

	// Display
	if (!settings.contains("language"))
	settings.setValue("language", "");
	if (!SoftSetArg("-lang", settings.value("language").toString().toStdString()))
	addOverriddenOption("-lang");

	language = settings.value("language").toString();
	}

	void OptionsModel::Reset()
	{
	QSettings settings;

	// Remove all entries from our QSettings object
	settings.clear();

	// default setting for OptionsModel::StartAtStartup - disabled
	if (GUIUtil::GetStartOnSystemStartup())
	GUIUtil::SetStartOnSystemStartup(false);
	}

	int OptionsModel::rowCount(const QModelIndex & parent) const
	{
	return OptionIDRowCount;
	}

	// read QSettings values and return them
	QVariant OptionsModel::data(const QModelIndex & index, int role) const
	{
	if(role == Qt::EditRole)
	{
	QSettings settings;
	switch(index.row())
	{
	case StartAtStartup:
	return GUIUtil::GetStartOnSystemStartup();
	case MinimizeToTray:
	return fMinimizeToTray;
	case MapPortUPnP:
	#ifdef USE_UPNP
	return settings.value("fUseUPnP");
	#else
	return false;
	#endif
	case MinimizeOnClose:
	return fMinimizeOnClose;

	// default proxy
	case ProxyUse:
	return settings.value("fUseProxy", false);
	case ProxyIP: {
	// contains IP at index 0 and port at index 1
	QStringList strlIpPort = settings.value("addrProxy").toString().split(":", QString::SkipEmptyParts);
	return strlIpPort.at(0);
	}
	case ProxyPort: {
	// contains IP at index 0 and port at index 1
	QStringList strlIpPort = settings.value("addrProxy").toString().split(":", QString::SkipEmptyParts);
	return strlIpPort.at(1);
	}
	case ProxySocksVersion:
	return settings.value("nSocksVersion", 5);

	#ifdef ENABLE_WALLET
	case Fee:
	// Attention: Init() is called before nTransactionFee is set in AppInit2()!
	// To ensure we can change the fee on-the-fly update our QSetting when
	// opening OptionsDialog, which queries Fee via the mapper.
	if (nTransactionFee != settings.value("nTransactionFee").toLongLong())
	settings.setValue("nTransactionFee", (qint64)nTransactionFee);
	// Todo: Consider to revert back to use just nTransactionFee here, if we don't want
	// -paytxfee to update our QSettings!
	return settings.value("nTransactionFee");
	case SpendZeroConfChange:
	return settings.value("bSpendZeroConfChange");
	#endif
	case DisplayUnit:
	return nDisplayUnit;
	case DisplayAddresses:
	return bDisplayAddresses;
	+ case ThirdPartyTxUrls:
	+ return strThirdPartyTxUrls;
	case Language:
	return settings.value("language");
	case CoinControlFeatures:
	return fCoinControlFeatures;
	case DatabaseCache:
	return settings.value("nDatabaseCache");
	case ThreadsScriptVerif:
	return settings.value("nThreadsScriptVerif");
	default:
	return QVariant();
	}
	}
	return QVariant();
	}

	// write QSettings values
	bool OptionsModel::setData(const QModelIndex & index, const QVariant & value, int role)
	{
	bool successful = true; /* set to false on parse error */
	if(role == Qt::EditRole)
	{
	QSettings settings;
	switch(index.row())
	{
	case StartAtStartup:
	successful = GUIUtil::SetStartOnSystemStartup(value.toBool());
	break;
	case MinimizeToTray:
	fMinimizeToTray = value.toBool();
	settings.setValue("fMinimizeToTray", fMinimizeToTray);
	break;
	case MapPortUPnP: // core option - can be changed on-the-fly
	settings.setValue("fUseUPnP", value.toBool());
	MapPort(value.toBool());
	break;
	case MinimizeOnClose:
	fMinimizeOnClose = value.toBool();
	settings.setValue("fMinimizeOnClose", fMinimizeOnClose);
	break;

	// default proxy
	case ProxyUse:
	if (settings.value("fUseProxy") != value) {
	settings.setValue("fUseProxy", value.toBool());
	setRestartRequired(true);
	}
	break;
	case ProxyIP: {
	// contains current IP at index 0 and current port at index 1
	QStringList strlIpPort = settings.value("addrProxy").toString().split(":", QString::SkipEmptyParts);
	// if that key doesn't exist or has a changed IP
	if (!settings.contains("addrProxy") \|\| strlIpPort.at(0) != value.toString()) {
	// construct new value from new IP and current port
	QString strNewValue = value.toString() + ":" + strlIpPort.at(1);
	settings.setValue("addrProxy", strNewValue);
	setRestartRequired(true);
	}
	}
	break;
	case ProxyPort: {
	// contains current IP at index 0 and current port at index 1
	QStringList strlIpPort = settings.value("addrProxy").toString().split(":", QString::SkipEmptyParts);
	// if that key doesn't exist or has a changed port
	if (!settings.contains("addrProxy") \|\| strlIpPort.at(1) != value.toString()) {
	// construct new value from current IP and new port
	QString strNewValue = strlIpPort.at(0) + ":" + value.toString();
	settings.setValue("addrProxy", strNewValue);
	setRestartRequired(true);
	}
	}
	break;
	case ProxySocksVersion: {
	if (settings.value("nSocksVersion") != value) {
	settings.setValue("nSocksVersion", value.toInt());
	setRestartRequired(true);
	}
	}
	break;
	#ifdef ENABLE_WALLET
	case Fee: // core option - can be changed on-the-fly
	// Todo: Add is valid check and warn via message, if not
	nTransactionFee = value.toLongLong();
	settings.setValue("nTransactionFee", (qint64)nTransactionFee);
	emit transactionFeeChanged(nTransactionFee);
	break;
	case SpendZeroConfChange:
	if (settings.value("bSpendZeroConfChange") != value) {
	settings.setValue("bSpendZeroConfChange", value);
	setRestartRequired(true);
	}
	break;
	#endif
	case DisplayUnit:
	nDisplayUnit = value.toInt();
	settings.setValue("nDisplayUnit", nDisplayUnit);
	emit displayUnitChanged(nDisplayUnit);
	break;
	case DisplayAddresses:
	bDisplayAddresses = value.toBool();
	settings.setValue("bDisplayAddresses", bDisplayAddresses);
	break;
	+ case ThirdPartyTxUrls:
	+ if (strThirdPartyTxUrls != value.toString()) {
	+ strThirdPartyTxUrls = value.toString();
	+ settings.setValue("strThirdPartyTxUrls", strThirdPartyTxUrls);
	+ setRestartRequired(true);
	+ }
	+ break;
	case Language:
	if (settings.value("language") != value) {
	settings.setValue("language", value);
	setRestartRequired(true);
	}
	break;
	case CoinControlFeatures:
	fCoinControlFeatures = value.toBool();
	settings.setValue("fCoinControlFeatures", fCoinControlFeatures);
	emit coinControlFeaturesChanged(fCoinControlFeatures);
	break;
	case DatabaseCache:
	if (settings.value("nDatabaseCache") != value) {
	settings.setValue("nDatabaseCache", value);
	setRestartRequired(true);
	}
	break;
	case ThreadsScriptVerif:
	if (settings.value("nThreadsScriptVerif") != value) {
	settings.setValue("nThreadsScriptVerif", value);
	setRestartRequired(true);
	}
	break;
	default:
	break;
	}
	}
	emit dataChanged(index, index);

	return successful;
	}

	bool OptionsModel::getProxySettings(QNetworkProxy& proxy) const
	{
	// Directly query current base proxy, because
	// GUI settings can be overridden with -proxy.
	proxyType curProxy;
	if (GetProxy(NET_IPV4, curProxy)) {
	if (curProxy.second == 5) {
	proxy.setType(QNetworkProxy::Socks5Proxy);
	proxy.setHostName(QString::fromStdString(curProxy.first.ToStringIP()));
	proxy.setPort(curProxy.first.GetPort());

	return true;
	}
	else
	return false;
	}
	else
	proxy.setType(QNetworkProxy::NoProxy);

	return true;
	}

	void OptionsModel::setRestartRequired(bool fRequired)
	{
	QSettings settings;
	return settings.setValue("fRestartRequired", fRequired);
	}

	bool OptionsModel::isRestartRequired()
	{
	QSettings settings;
	return settings.value("fRestartRequired", false).toBool();
	}
	diff --git a/src/qt/optionsmodel.h b/src/qt/optionsmodel.h
	index ece5ef78a..f05e3e92d 100644
	--- a/src/qt/optionsmodel.h
	+++ b/src/qt/optionsmodel.h
	@@ -1,87 +1,90 @@
	// 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 OPTIONSMODEL_H
	#define OPTIONSMODEL_H

	#include <QAbstractListModel>

	QT_BEGIN_NAMESPACE
	class QNetworkProxy;
	QT_END_NAMESPACE

	/** Interface from Qt to configuration data structure for Bitcoin client.
	To Qt, the options are presented as a list with the different options
	laid out vertically.
	This can be changed to a tree once the settings become sufficiently
	complex.
	*/
	class OptionsModel : public QAbstractListModel
	{
	Q_OBJECT

	public:
	explicit OptionsModel(QObject *parent = 0);

	enum OptionID {
	StartAtStartup, // bool
	MinimizeToTray, // bool
	MapPortUPnP, // bool
	MinimizeOnClose, // bool
	ProxyUse, // bool
	ProxyIP, // QString
	ProxyPort, // int
	ProxySocksVersion, // int
	Fee, // qint64
	DisplayUnit, // BitcoinUnits::Unit
	DisplayAddresses, // bool
	+ ThirdPartyTxUrls, // QString
	Language, // QString
	CoinControlFeatures, // bool
	ThreadsScriptVerif, // int
	DatabaseCache, // int
	SpendZeroConfChange, // bool
	OptionIDRowCount,
	};

	void Init();
	void Reset();

	int rowCount(const QModelIndex & parent = QModelIndex()) const;
	QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const;
	bool setData(const QModelIndex & index, const QVariant & value, int role = Qt::EditRole);

	/* Explicit getters */
	bool getMinimizeToTray() { return fMinimizeToTray; }
	bool getMinimizeOnClose() { return fMinimizeOnClose; }
	int getDisplayUnit() { return nDisplayUnit; }
	bool getDisplayAddresses() { return bDisplayAddresses; }
	+ QString getThirdPartyTxUrls() { return strThirdPartyTxUrls; }
	bool getProxySettings(QNetworkProxy& proxy) const;
	bool getCoinControlFeatures() { return fCoinControlFeatures; }
	const QString& getOverriddenByCommandLine() { return strOverriddenByCommandLine; }

	/* Restart flag helper */
	void setRestartRequired(bool fRequired);
	bool isRestartRequired();

	private:
	/* Qt-only settings */
	bool fMinimizeToTray;
	bool fMinimizeOnClose;
	QString language;
	int nDisplayUnit;
	bool bDisplayAddresses;
	+ QString strThirdPartyTxUrls;
	bool fCoinControlFeatures;
	/* settings that were overriden by command-line */
	QString strOverriddenByCommandLine;

	/// Add option to list of GUI options overridden through command line/config file
	void addOverriddenOption(const std::string &option);

	signals:
	void displayUnitChanged(int unit);
	void transactionFeeChanged(qint64);
	void coinControlFeaturesChanged(bool);
	};

	#endif // OPTIONSMODEL_H
	diff --git a/src/qt/transactiontablemodel.cpp b/src/qt/transactiontablemodel.cpp
	index df412650d..8cf2b0a1b 100644
	--- a/src/qt/transactiontablemodel.cpp
	+++ b/src/qt/transactiontablemodel.cpp
	@@ -1,626 +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 str = BitcoinUnits::format(walletModel->getOptionsModel()->getDisplayUnit(), wtx->credit + wtx->debit);
	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);
	}
	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);
	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 04b5291f4..333e6bc6e 100644
	--- a/src/qt/transactiontablemodel.h
	+++ b/src/qt/transactiontablemodel.h
	@@ -1,92 +1,94 @@
	// 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>

	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 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 a36315091..d4d29416c 100644
	--- a/src/qt/transactionview.cpp
	+++ b/src/qt/transactionview.cpp
	@@ -1,447 +1,482 @@
	// 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);

	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);
	}
	diff --git a/src/qt/transactionview.h b/src/qt/transactionview.h
	index ef4f9d6f3..7a89fa11c 100644
	--- a/src/qt/transactionview.h
	+++ b/src/qt/transactionview.h
	@@ -1,105 +1,108 @@
	// 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>

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

	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: Sun, Mar 2, 09:53 (1 d, 4 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187262
Default Alt Text: (93 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions