No OneTemporary
Actions

Size

146 KB

Subscribers

None

View Options

	diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
	index 6cc6b99ceb..d9ca423015 100644
	--- a/src/qt/bitcoin.cpp
	+++ b/src/qt/bitcoin.cpp
	@@ -1,632 +1,635 @@
	// 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 "config/bitcoin-config.h"
	#endif

	#include "bitcoingui.h"

	#include "clientmodel.h"
	#include "guiconstants.h"
	#include "guiutil.h"
	#include "intro.h"
	#include "optionsmodel.h"
	#include "splashscreen.h"
	#include "utilitydialog.h"
	#include "winshutdownmonitor.h"
	+
	#ifdef ENABLE_WALLET
	#include "paymentserver.h"
	#include "walletmodel.h"
	#endif

	#include "init.h"
	#include "main.h"
	#include "rpcserver.h"
	#include "ui_interface.h"
	#include "util.h"
	+
	#ifdef ENABLE_WALLET
	#include "wallet.h"
	#endif

	#include <stdint.h>

	#include <boost/filesystem/operations.hpp>
	#include <boost/thread.hpp>
	+
	#include <QApplication>
	#include <QDebug>
	#include <QLibraryInfo>
	#include <QLocale>
	#include <QMessageBox>
	#include <QSettings>
	+#include <QThread>
	#include <QTimer>
	#include <QTranslator>
	-#include <QThread>

	#if defined(QT_STATICPLUGIN)
	#include <QtPlugin>
	#if QT_VERSION < 0x050000
	Q_IMPORT_PLUGIN(qcncodecs)
	Q_IMPORT_PLUGIN(qjpcodecs)
	Q_IMPORT_PLUGIN(qtwcodecs)
	Q_IMPORT_PLUGIN(qkrcodecs)
	Q_IMPORT_PLUGIN(qtaccessiblewidgets)
	#else
	Q_IMPORT_PLUGIN(AccessibleFactory)
	#if defined(QT_QPA_PLATFORM_XCB)
	Q_IMPORT_PLUGIN(QXcbIntegrationPlugin);
	#elif defined(QT_QPA_PLATFORM_WINDOWS)
	Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin);
	#elif defined(QT_QPA_PLATFORM_COCOA)
	Q_IMPORT_PLUGIN(QCocoaIntegrationPlugin);
	#endif
	#endif
	#endif

	#if QT_VERSION < 0x050000
	#include <QTextCodec>
	#endif

	// Declare meta types used for QMetaObject::invokeMethod
	Q_DECLARE_METATYPE(bool*)

	static void InitMessage(const std::string &message)
	{
	LogPrintf("init message: %s\n", message);
	}

	/*
	Translate string to current locale using Qt.
	*/
	static std::string Translate(const char* psz)
	{
	return QCoreApplication::translate("bitcoin-core", psz).toStdString();
	}

	/** Set up translations */
	static void initTranslations(QTranslator &qtTranslatorBase, QTranslator &qtTranslator, QTranslator &translatorBase, QTranslator &translator)
	{
	QSettings settings;

	// Remove old translators
	QApplication::removeTranslator(&qtTranslatorBase);
	QApplication::removeTranslator(&qtTranslator);
	QApplication::removeTranslator(&translatorBase);
	QApplication::removeTranslator(&translator);

	// Get desired locale (e.g. "de_DE")
	// 1) System default language
	QString lang_territory = QLocale::system().name();
	// 2) Language from QSettings
	QString lang_territory_qsettings = settings.value("language", "").toString();
	if(!lang_territory_qsettings.isEmpty())
	lang_territory = lang_territory_qsettings;
	// 3) -lang command line argument
	lang_territory = QString::fromStdString(GetArg("-lang", lang_territory.toStdString()));

	// Convert to "de" only by truncating "_DE"
	QString lang = lang_territory;
	lang.truncate(lang_territory.lastIndexOf('_'));

	// Load language files for configured locale:
	// - First load the translator for the base language, without territory
	// - Then load the more specific locale translator

	// Load e.g. qt_de.qm
	if (qtTranslatorBase.load("qt_" + lang, QLibraryInfo::location(QLibraryInfo::TranslationsPath)))
	QApplication::installTranslator(&qtTranslatorBase);

	// Load e.g. qt_de_DE.qm
	if (qtTranslator.load("qt_" + lang_territory, QLibraryInfo::location(QLibraryInfo::TranslationsPath)))
	QApplication::installTranslator(&qtTranslator);

	// Load e.g. bitcoin_de.qm (shortcut "de" needs to be defined in bitcoin.qrc)
	if (translatorBase.load(lang, ":/translations/"))
	QApplication::installTranslator(&translatorBase);

	// Load e.g. bitcoin_de_DE.qm (shortcut "de_DE" needs to be defined in bitcoin.qrc)
	if (translator.load(lang_territory, ":/translations/"))
	QApplication::installTranslator(&translator);
	}

	/* qDebug() message handler --> debug.log */
	#if QT_VERSION < 0x050000
	void DebugMessageHandler(QtMsgType type, const char *msg)
	{
	const char *category = (type == QtDebugMsg) ? "qt" : NULL;
	LogPrint(category, "GUI: %s\n", msg);
	}
	#else
	void DebugMessageHandler(QtMsgType type, const QMessageLogContext& context, const QString &msg)
	{
	Q_UNUSED(context);
	const char *category = (type == QtDebugMsg) ? "qt" : NULL;
	LogPrint(category, "GUI: %s\n", msg.toStdString());
	}
	#endif

	/** Class encapsulating Bitcoin Core startup and shutdown.
	* Allows running startup and shutdown in a different thread from the UI thread.
	*/
	class BitcoinCore: public QObject
	{
	Q_OBJECT
	public:
	explicit BitcoinCore();

	public slots:
	void initialize();
	void shutdown();

	signals:
	void initializeResult(int retval);
	void shutdownResult(int retval);
	void runawayException(const QString &message);

	private:
	boost::thread_group threadGroup;

	/// Pass fatal exception message to UI thread
	void handleRunawayException(std::exception *e);
	};

	/** Main Bitcoin application object */
	class BitcoinApplication: public QApplication
	{
	Q_OBJECT
	public:
	explicit BitcoinApplication(int &argc, char **argv);
	~BitcoinApplication();

	#ifdef ENABLE_WALLET
	/// Create payment server
	void createPaymentServer();
	#endif
	/// Create options model
	void createOptionsModel();
	/// Create main window
	void createWindow(bool isaTestNet);
	/// Create splash screen
	void createSplashScreen(bool isaTestNet);

	/// Request core initialization
	void requestInitialize();
	/// Request core shutdown
	void requestShutdown();

	/// Get process return value
	int getReturnValue() { return returnValue; }

	/// Get window identifier of QMainWindow (BitcoinGUI)
	WId getMainWinId() const;

	public slots:
	void initializeResult(int retval);
	void shutdownResult(int retval);
	/// Handle runaway exceptions. Shows a message box with the problem and quits the program.
	void handleRunawayException(const QString &message);

	signals:
	void requestedInitialize();
	void requestedShutdown();
	void stopThread();
	void splashFinished(QWidget *window);

	private:
	QThread *coreThread;
	OptionsModel *optionsModel;
	ClientModel *clientModel;
	BitcoinGUI *window;
	QTimer *pollShutdownTimer;
	#ifdef ENABLE_WALLET
	PaymentServer* paymentServer;
	WalletModel *walletModel;
	#endif
	int returnValue;

	void startThread();
	};

	#include "bitcoin.moc"

	BitcoinCore::BitcoinCore():
	QObject()
	{
	}

	void BitcoinCore::handleRunawayException(std::exception *e)
	{
	PrintExceptionContinue(e, "Runaway exception");
	emit runawayException(QString::fromStdString(strMiscWarning));
	}

	void BitcoinCore::initialize()
	{
	try
	{
	qDebug() << __func__ << ": Running AppInit2 in thread";
	int rv = AppInit2(threadGroup);
	if(rv)
	{
	/* Start a dummy RPC thread if no RPC thread is active yet
	* to handle timeouts.
	*/
	StartDummyRPCThread();
	}
	emit initializeResult(rv);
	} catch (std::exception& e) {
	handleRunawayException(&e);
	} catch (...) {
	handleRunawayException(NULL);
	}
	}

	void BitcoinCore::shutdown()
	{
	try
	{
	qDebug() << __func__ << ": Running Shutdown in thread";
	threadGroup.interrupt_all();
	threadGroup.join_all();
	Shutdown();
	qDebug() << __func__ << ": Shutdown finished";
	emit shutdownResult(1);
	} catch (std::exception& e) {
	handleRunawayException(&e);
	} catch (...) {
	handleRunawayException(NULL);
	}
	}

	BitcoinApplication::BitcoinApplication(int &argc, char **argv):
	QApplication(argc, argv),
	coreThread(0),
	optionsModel(0),
	clientModel(0),
	window(0),
	pollShutdownTimer(0),
	#ifdef ENABLE_WALLET
	paymentServer(0),
	walletModel(0),
	#endif
	returnValue(0)
	{
	setQuitOnLastWindowClosed(false);
	}

	BitcoinApplication::~BitcoinApplication()
	{
	if(coreThread)
	{
	qDebug() << __func__ << ": Stopping thread";
	emit stopThread();
	coreThread->wait();
	qDebug() << __func__ << ": Stopped thread";
	}

	delete window;
	window = 0;
	#ifdef ENABLE_WALLET
	delete paymentServer;
	paymentServer = 0;
	#endif
	delete optionsModel;
	optionsModel = 0;
	}

	#ifdef ENABLE_WALLET
	void BitcoinApplication::createPaymentServer()
	{
	paymentServer = new PaymentServer(this);
	}
	#endif

	void BitcoinApplication::createOptionsModel()
	{
	optionsModel = new OptionsModel();
	}

	void BitcoinApplication::createWindow(bool isaTestNet)
	{
	window = new BitcoinGUI(isaTestNet, 0);

	pollShutdownTimer = new QTimer(window);
	connect(pollShutdownTimer, SIGNAL(timeout()), window, SLOT(detectShutdown()));
	pollShutdownTimer->start(200);
	}

	void BitcoinApplication::createSplashScreen(bool isaTestNet)
	{
	SplashScreen *splash = new SplashScreen(QPixmap(), 0, isaTestNet);
	splash->setAttribute(Qt::WA_DeleteOnClose);
	splash->show();
	connect(this, SIGNAL(splashFinished(QWidget)), splash, SLOT(slotFinish(QWidget)));
	}

	void BitcoinApplication::startThread()
	{
	if(coreThread)
	return;
	coreThread = new QThread(this);
	BitcoinCore *executor = new BitcoinCore();
	executor->moveToThread(coreThread);

	/* communication to and from thread */
	connect(executor, SIGNAL(initializeResult(int)), this, SLOT(initializeResult(int)));
	connect(executor, SIGNAL(shutdownResult(int)), this, SLOT(shutdownResult(int)));
	connect(executor, SIGNAL(runawayException(QString)), this, SLOT(handleRunawayException(QString)));
	connect(this, SIGNAL(requestedInitialize()), executor, SLOT(initialize()));
	connect(this, SIGNAL(requestedShutdown()), executor, SLOT(shutdown()));
	/* make sure executor object is deleted in its own thread */
	connect(this, SIGNAL(stopThread()), executor, SLOT(deleteLater()));
	connect(this, SIGNAL(stopThread()), coreThread, SLOT(quit()));

	coreThread->start();
	}

	void BitcoinApplication::requestInitialize()
	{
	qDebug() << __func__ << ": Requesting initialize";
	startThread();
	emit requestedInitialize();
	}

	void BitcoinApplication::requestShutdown()
	{
	qDebug() << __func__ << ": Requesting shutdown";
	startThread();
	window->hide();
	window->setClientModel(0);
	pollShutdownTimer->stop();

	#ifdef ENABLE_WALLET
	window->removeAllWallets();
	delete walletModel;
	walletModel = 0;
	#endif
	delete clientModel;
	clientModel = 0;

	// Show a simple window indicating shutdown status
	ShutdownWindow::showShutdownWindow(window);

	// Request shutdown from core thread
	emit requestedShutdown();
	}

	void BitcoinApplication::initializeResult(int retval)
	{
	qDebug() << __func__ << ": Initialization result: " << retval;
	// Set exit result: 0 if successful, 1 if failure
	returnValue = retval ? 0 : 1;
	if(retval)
	{
	#ifdef ENABLE_WALLET
	PaymentServer::LoadRootCAs();
	paymentServer->setOptionsModel(optionsModel);
	#endif

	clientModel = new ClientModel(optionsModel);
	window->setClientModel(clientModel);

	#ifdef ENABLE_WALLET
	if(pwalletMain)
	{
	walletModel = new WalletModel(pwalletMain, optionsModel);

	window->addWallet(BitcoinGUI::DEFAULT_WALLET, walletModel);
	window->setCurrentWallet(BitcoinGUI::DEFAULT_WALLET);

	connect(walletModel, SIGNAL(coinsSent(CWallet*,SendCoinsRecipient,QByteArray)),
	paymentServer, SLOT(fetchPaymentACK(CWallet*,const SendCoinsRecipient&,QByteArray)));
	}
	#endif

	emit splashFinished(window);

	// If -min option passed, start window minimized.
	if(GetBoolArg("-min", false))
	{
	window->showMinimized();
	}
	else
	{
	window->show();
	}
	#ifdef ENABLE_WALLET
	// Now that initialization/startup is done, process any command-line
	// bitcoin: URIs or payment requests:
	connect(paymentServer, SIGNAL(receivedPaymentRequest(SendCoinsRecipient)),
	window, SLOT(handlePaymentRequest(SendCoinsRecipient)));
	connect(window, SIGNAL(receivedURI(QString)),
	paymentServer, SLOT(handleURIOrFile(QString)));
	connect(paymentServer, SIGNAL(message(QString,QString,unsigned int)),
	window, SLOT(message(QString,QString,unsigned int)));
	QTimer::singleShot(100, paymentServer, SLOT(uiReady()));
	#endif
	} else {
	quit(); // Exit main loop
	}
	}

	void BitcoinApplication::shutdownResult(int retval)
	{
	qDebug() << __func__ << ": Shutdown result: " << retval;
	quit(); // Exit main loop after shutdown finished
	}

	void BitcoinApplication::handleRunawayException(const QString &message)
	{
	QMessageBox::critical(0, "Runaway exception", BitcoinGUI::tr("A fatal error occurred. Bitcoin can no longer continue safely and will quit.") + QString("\n\n") + message);
	::exit(1);
	}

	WId BitcoinApplication::getMainWinId() const
	{
	if (!window)
	return 0;

	return window->winId();
	}

	#ifndef BITCOIN_QT_TEST
	int main(int argc, char *argv[])
	{
	SetupEnvironment();

	/// 1. Parse command-line options. These take precedence over anything else.
	// Command-line options take precedence:
	ParseParameters(argc, argv);

	// Do not refer to data directory yet, this can be overridden by Intro::pickDataDirectory

	/// 2. Basic Qt initialization (not dependent on parameters or configuration)
	#if QT_VERSION < 0x050000
	// Internal string conversion is all UTF-8
	QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
	QTextCodec::setCodecForCStrings(QTextCodec::codecForTr());
	#endif

	Q_INIT_RESOURCE(bitcoin);
	Q_INIT_RESOURCE(bitcoin_locale);

	GUIUtil::SubstituteFonts();

	BitcoinApplication app(argc, argv);
	#if QT_VERSION > 0x050100
	// Generate high-dpi pixmaps
	QApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
	#endif
	#ifdef Q_OS_MAC
	QApplication::setAttribute(Qt::AA_DontShowIconsInMenus);
	#endif

	// Register meta types used for QMetaObject::invokeMethod
	qRegisterMetaType< bool* >();

	/// 3. Application identification
	// must be set before OptionsModel is initialized or translations are loaded,
	// as it is used to locate QSettings
	QApplication::setOrganizationName(QAPP_ORG_NAME);
	QApplication::setOrganizationDomain(QAPP_ORG_DOMAIN);
	QApplication::setApplicationName(QAPP_APP_NAME_DEFAULT);

	/// 4. Initialization of translations, so that intro dialog is in user's language
	// Now that QSettings are accessible, initialize translations
	QTranslator qtTranslatorBase, qtTranslator, translatorBase, translator;
	initTranslations(qtTranslatorBase, qtTranslator, translatorBase, translator);
	uiInterface.Translate.connect(Translate);

	// Show help message immediately after parsing command-line options (for "-lang") and setting locale,
	// but before showing splash screen.
	if (mapArgs.count("-?") \|\| mapArgs.count("-help") \|\| mapArgs.count("-version"))
	{
	HelpMessageDialog help(NULL, mapArgs.count("-version"));
	help.showOrPrint();
	return 1;
	}

	/// 5. Now that settings and translations are available, ask user for data directory
	// User language is set up: pick a data directory
	Intro::pickDataDirectory();

	/// 6. Determine availability of data directory and parse bitcoin.conf
	/// - Do not call GetDataDir(true) before this step finishes
	if (!boost::filesystem::is_directory(GetDataDir(false)))
	{
	QMessageBox::critical(0, QObject::tr("Bitcoin Core"),
	QObject::tr("Error: Specified data directory \"%1\" does not exist.").arg(QString::fromStdString(mapArgs["-datadir"])));
	return 1;
	}
	try {
	ReadConfigFile(mapArgs, mapMultiArgs);
	} catch(std::exception &e) {
	QMessageBox::critical(0, QObject::tr("Bitcoin Core"),
	QObject::tr("Error: Cannot parse configuration file: %1. Only use key=value syntax.").arg(e.what()));
	return false;
	}

	/// 7. Determine network (and switch to network specific options)
	// - Do not call Params() before this step
	// - Do this after parsing the configuration file, as the network can be switched there
	// - QSettings() will use the new application name after this, resulting in network-specific settings
	// - Needs to be done before createOptionsModel

	// Check for -testnet or -regtest parameter (Params() calls are only valid after this clause)
	if (!SelectParamsFromCommandLine()) {
	QMessageBox::critical(0, QObject::tr("Bitcoin Core"), QObject::tr("Error: Invalid combination of -regtest and -testnet."));
	return 1;
	}
	#ifdef ENABLE_WALLET
	// Parse URIs on command line -- this can affect Params()
	if (!PaymentServer::ipcParseCommandLine(argc, argv))
	exit(0);
	#endif
	bool isaTestNet = Params().NetworkID() != CBaseChainParams::MAIN;
	// Allow for separate UI settings for testnets
	if (isaTestNet)
	QApplication::setApplicationName(QAPP_APP_NAME_TESTNET);
	else
	QApplication::setApplicationName(QAPP_APP_NAME_DEFAULT);
	// Re-initialize translations after changing application name (language in network-specific settings can be different)
	initTranslations(qtTranslatorBase, qtTranslator, translatorBase, translator);

	#ifdef ENABLE_WALLET
	/// 8. URI IPC sending
	// - Do this early as we don't want to bother initializing if we are just calling IPC
	// - Do this after setting up the data directory, as the data directory hash is used in the name
	// of the server.
	// - Do this after creating app and setting up translations, so errors are
	// translated properly.
	if (PaymentServer::ipcSendCommandLine())
	exit(0);

	// Start up the payment server early, too, so impatient users that click on
	// bitcoin: links repeatedly have their payment requests routed to this process:
	app.createPaymentServer();
	#endif

	/// 9. Main GUI initialization
	// Install global event filter that makes sure that long tooltips can be word-wrapped
	app.installEventFilter(new GUIUtil::ToolTipToRichTextFilter(TOOLTIP_WRAP_THRESHOLD, &app));
	#if QT_VERSION < 0x050000
	// Install qDebug() message handler to route to debug.log
	qInstallMsgHandler(DebugMessageHandler);
	#else
	#if defined(Q_OS_WIN)
	// Install global event filter for processing Windows session related Windows messages (WM_QUERYENDSESSION and WM_ENDSESSION)
	qApp->installNativeEventFilter(new WinShutdownMonitor());
	#endif
	// Install qDebug() message handler to route to debug.log
	qInstallMessageHandler(DebugMessageHandler);
	#endif
	// Load GUI settings from QSettings
	app.createOptionsModel();

	// Subscribe to global signals from core
	uiInterface.InitMessage.connect(InitMessage);

	if (GetBoolArg("-splash", true) && !GetBoolArg("-min", false))
	app.createSplashScreen(isaTestNet);

	try
	{
	app.createWindow(isaTestNet);
	app.requestInitialize();
	#if defined(Q_OS_WIN) && QT_VERSION >= 0x050000
	WinShutdownMonitor::registerShutdownBlockReason(QObject::tr("Bitcoin Core didn't yet exit safely..."), (HWND)app.getMainWinId());
	#endif
	app.exec();
	app.requestShutdown();
	app.exec();
	} catch (std::exception& e) {
	PrintExceptionContinue(&e, "Runaway exception");
	app.handleRunawayException(QString::fromStdString(strMiscWarning));
	} catch (...) {
	PrintExceptionContinue(NULL, "Runaway exception");
	app.handleRunawayException(QString::fromStdString(strMiscWarning));
	}
	return app.getReturnValue();
	}
	#endif // BITCOIN_QT_TEST
	diff --git a/src/qt/bitcoinamountfield.h b/src/qt/bitcoinamountfield.h
	index c713f5d687..84795a7e7a 100644
	--- a/src/qt/bitcoinamountfield.h
	+++ b/src/qt/bitcoinamountfield.h
	@@ -1,68 +1,68 @@
	// 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 BITCOINAMOUNTFIELD_H
	#define BITCOINAMOUNTFIELD_H

	#include <QWidget>

	+class AmountSpinBox;
	+
	QT_BEGIN_NAMESPACE
	class QValueComboBox;
	QT_END_NAMESPACE

	-class AmountSpinBox;
	-
	/** Widget for entering bitcoin amounts.
	*/
	class BitcoinAmountField: public QWidget
	{
	Q_OBJECT

	Q_PROPERTY(qint64 value READ value WRITE setValue NOTIFY valueChanged USER true)

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

	qint64 value(bool *valid=0) const;
	void setValue(qint64 value);

	/ Set single step in satoshis /
	void setSingleStep(qint64 step);

	/ Make read-only /
	void setReadOnly(bool fReadOnly);

	/** Mark current value as invalid in UI. */
	void setValid(bool valid);
	/** Perform input validation, mark field as invalid if entered value is not valid. */
	bool validate();

	/** Change unit used to display amount. */
	void setDisplayUnit(int unit);

	/** Make field empty and ready for new input. */
	void clear();

	/** Qt messes up the tab chain by default in some cases (issue https://bugreports.qt-project.org/browse/QTBUG-10907),
	in these cases we have to set it up manually.
	*/
	QWidget setupTabChain(QWidget prev);

	signals:
	void valueChanged();

	protected:
	/** Intercept focus-in event and ',' key presses */
	bool eventFilter(QObject object, QEvent event);

	private:
	AmountSpinBox *amount;
	QValueComboBox *unit;

	private slots:
	void unitChanged(int idx);

	};

	#endif // BITCOINAMOUNTFIELD_H
	diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
	index 790301a1eb..dd5192982e 100644
	--- a/src/qt/bitcoingui.cpp
	+++ b/src/qt/bitcoingui.cpp
	@@ -1,1104 +1,1105 @@
	// 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 "bitcoingui.h"

	#include "bitcoinunits.h"
	#include "clientmodel.h"
	#include "guiconstants.h"
	#include "guiutil.h"
	#include "notificator.h"
	#include "openuridialog.h"
	#include "optionsdialog.h"
	#include "optionsmodel.h"
	#include "rpcconsole.h"
	#include "utilitydialog.h"
	+
	#ifdef ENABLE_WALLET
	#include "walletframe.h"
	#include "walletmodel.h"
	#endif

	#ifdef Q_OS_MAC
	#include "macdockiconhandler.h"
	#endif

	#include "init.h"
	-#include "util.h"
	#include "ui_interface.h"
	+#include "util.h"

	#include <iostream>

	#include <QAction>
	#include <QApplication>
	#include <QDateTime>
	#include <QDesktopWidget>
	#include <QDragEnterEvent>
	#include <QIcon>
	#include <QListWidget>
	#include <QMenuBar>
	#include <QMessageBox>
	#include <QMimeData>
	#include <QProgressBar>
	#include <QProgressDialog>
	#include <QSettings>
	#include <QStackedWidget>
	#include <QStatusBar>
	#include <QStyle>
	#include <QTimer>
	#include <QToolBar>
	#include <QVBoxLayout>

	#if QT_VERSION < 0x050000
	-#include <QUrl>
	#include <QTextDocument>
	+#include <QUrl>
	#else
	#include <QUrlQuery>
	#endif

	const QString BitcoinGUI::DEFAULT_WALLET = "~Default";

	BitcoinGUI::BitcoinGUI(bool fIsTestnet, QWidget *parent) :
	QMainWindow(parent),
	clientModel(0),
	walletFrame(0),
	unitDisplayControl(0),
	labelEncryptionIcon(0),
	labelConnectionsIcon(0),
	labelBlocksIcon(0),
	progressBarLabel(0),
	progressBar(0),
	progressDialog(0),
	appMenuBar(0),
	overviewAction(0),
	historyAction(0),
	quitAction(0),
	sendCoinsAction(0),
	usedSendingAddressesAction(0),
	usedReceivingAddressesAction(0),
	signMessageAction(0),
	verifyMessageAction(0),
	aboutAction(0),
	receiveCoinsAction(0),
	optionsAction(0),
	toggleHideAction(0),
	encryptWalletAction(0),
	backupWalletAction(0),
	changePassphraseAction(0),
	aboutQtAction(0),
	openRPCConsoleAction(0),
	openAction(0),
	showHelpMessageAction(0),
	trayIcon(0),
	trayIconMenu(0),
	notificator(0),
	rpcConsole(0),
	prevBlocks(0),
	spinnerFrame(0)
	{
	GUIUtil::restoreWindowGeometry("nWindow", QSize(850, 550), this);

	QString windowTitle = tr("Bitcoin Core") + " - ";
	#ifdef ENABLE_WALLET
	/* if compiled with wallet support, -disablewallet can still disable the wallet */
	bool enableWallet = !GetBoolArg("-disablewallet", false);
	#else
	bool enableWallet = false;
	#endif
	if(enableWallet)
	{
	windowTitle += tr("Wallet");
	} else {
	windowTitle += tr("Node");
	}

	if (!fIsTestnet)
	{
	#ifndef Q_OS_MAC
	QApplication::setWindowIcon(QIcon(":icons/bitcoin"));
	setWindowIcon(QIcon(":icons/bitcoin"));
	#else
	MacDockIconHandler::instance()->setIcon(QIcon(":icons/bitcoin"));
	#endif
	}
	else
	{
	windowTitle += " " + tr("[testnet]");
	#ifndef Q_OS_MAC
	QApplication::setWindowIcon(QIcon(":icons/bitcoin_testnet"));
	setWindowIcon(QIcon(":icons/bitcoin_testnet"));
	#else
	MacDockIconHandler::instance()->setIcon(QIcon(":icons/bitcoin_testnet"));
	#endif
	}
	setWindowTitle(windowTitle);

	#if defined(Q_OS_MAC) && QT_VERSION < 0x050000
	// This property is not implemented in Qt 5. Setting it has no effect.
	// A replacement API (QtMacUnifiedToolBar) is available in QtMacExtras.
	setUnifiedTitleAndToolBarOnMac(true);
	#endif

	rpcConsole = new RPCConsole(enableWallet ? this : 0);
	#ifdef ENABLE_WALLET
	if(enableWallet)
	{
	/** Create wallet frame and make it the central widget */
	walletFrame = new WalletFrame(this);
	setCentralWidget(walletFrame);
	} else
	#endif
	{
	/* When compiled without wallet or -disablewallet is provided,
	* the central widget is the rpc console.
	*/
	setCentralWidget(rpcConsole);
	}

	// Accept D&D of URIs
	setAcceptDrops(true);

	// Create actions for the toolbar, menu bar and tray/dock icon
	// Needs walletFrame to be initialized
	createActions(fIsTestnet);

	// Create application menu bar
	createMenuBar();

	// Create the toolbars
	createToolBars();

	// Create system tray icon and notification
	createTrayIcon(fIsTestnet);

	// Create status bar
	statusBar();

	// Status bar notification icons
	QFrame *frameBlocks = new QFrame();
	frameBlocks->setContentsMargins(0,0,0,0);
	frameBlocks->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
	QHBoxLayout *frameBlocksLayout = new QHBoxLayout(frameBlocks);
	frameBlocksLayout->setContentsMargins(3,0,3,0);
	frameBlocksLayout->setSpacing(3);
	unitDisplayControl = new UnitDisplayStatusBarControl();
	labelEncryptionIcon = new QLabel();
	labelConnectionsIcon = new QLabel();
	labelBlocksIcon = new QLabel();
	if(enableWallet)
	{
	frameBlocksLayout->addStretch();
	frameBlocksLayout->addWidget(unitDisplayControl);
	frameBlocksLayout->addStretch();
	frameBlocksLayout->addWidget(labelEncryptionIcon);
	}
	frameBlocksLayout->addStretch();
	frameBlocksLayout->addWidget(labelConnectionsIcon);
	frameBlocksLayout->addStretch();
	frameBlocksLayout->addWidget(labelBlocksIcon);
	frameBlocksLayout->addStretch();

	// Progress bar and label for blocks download
	progressBarLabel = new QLabel();
	progressBarLabel->setVisible(false);
	progressBar = new QProgressBar();
	progressBar->setAlignment(Qt::AlignCenter);
	progressBar->setVisible(false);

	// Override style sheet for progress bar for styles that have a segmented progress bar,
	// as they make the text unreadable (workaround for issue #1071)
	// See https://qt-project.org/doc/qt-4.8/gallery.html
	QString curStyle = QApplication::style()->metaObject()->className();
	if(curStyle == "QWindowsStyle" \|\| curStyle == "QWindowsXPStyle")
	{
	progressBar->setStyleSheet("QProgressBar { background-color: #e8e8e8; border: 1px solid grey; border-radius: 7px; padding: 1px; text-align: center; } QProgressBar::chunk { background: QLinearGradient(x1: 0, y1: 0, x2: 1, y2: 0, stop: 0 #FF8000, stop: 1 orange); border-radius: 7px; margin: 0px; }");
	}

	statusBar()->addWidget(progressBarLabel);
	statusBar()->addWidget(progressBar);
	statusBar()->addPermanentWidget(frameBlocks);

	connect(openRPCConsoleAction, SIGNAL(triggered()), rpcConsole, SLOT(show()));

	// prevents an open debug window from becoming stuck/unusable on client shutdown
	connect(quitAction, SIGNAL(triggered()), rpcConsole, SLOT(hide()));

	// Install event filter to be able to catch status tip events (QEvent::StatusTip)
	this->installEventFilter(this);

	// Initially wallet actions should be disabled
	setWalletActionsEnabled(false);

	// Subscribe to notifications from core
	subscribeToCoreSignals();
	}

	BitcoinGUI::~BitcoinGUI()
	{
	// Unsubscribe from notifications from core
	unsubscribeFromCoreSignals();

	GUIUtil::saveWindowGeometry("nWindow", this);
	if(trayIcon) // Hide tray icon, as deleting will let it linger until quit (on Ubuntu)
	trayIcon->hide();
	#ifdef Q_OS_MAC
	delete appMenuBar;
	MacDockIconHandler::instance()->setMainWindow(NULL);
	#endif
	}

	void BitcoinGUI::createActions(bool fIsTestnet)
	{
	QActionGroup *tabGroup = new QActionGroup(this);

	overviewAction = new QAction(QIcon(":/icons/overview"), tr("&Overview"), this);
	overviewAction->setStatusTip(tr("Show general overview of wallet"));
	overviewAction->setToolTip(overviewAction->statusTip());
	overviewAction->setCheckable(true);
	overviewAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_1));
	tabGroup->addAction(overviewAction);

	sendCoinsAction = new QAction(QIcon(":/icons/send"), tr("&Send"), this);
	sendCoinsAction->setStatusTip(tr("Send coins to a Bitcoin address"));
	sendCoinsAction->setToolTip(sendCoinsAction->statusTip());
	sendCoinsAction->setCheckable(true);
	sendCoinsAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_2));
	tabGroup->addAction(sendCoinsAction);

	receiveCoinsAction = new QAction(QIcon(":/icons/receiving_addresses"), tr("&Receive"), this);
	receiveCoinsAction->setStatusTip(tr("Request payments (generates QR codes and bitcoin: URIs)"));
	receiveCoinsAction->setToolTip(receiveCoinsAction->statusTip());
	receiveCoinsAction->setCheckable(true);
	receiveCoinsAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_3));
	tabGroup->addAction(receiveCoinsAction);

	historyAction = new QAction(QIcon(":/icons/history"), tr("&Transactions"), this);
	historyAction->setStatusTip(tr("Browse transaction history"));
	historyAction->setToolTip(historyAction->statusTip());
	historyAction->setCheckable(true);
	historyAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_4));
	tabGroup->addAction(historyAction);

	// These showNormalIfMinimized are needed because Send Coins and Receive Coins
	// can be triggered from the tray menu, and need to show the GUI to be useful.
	connect(overviewAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
	connect(overviewAction, SIGNAL(triggered()), this, SLOT(gotoOverviewPage()));
	connect(sendCoinsAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
	connect(sendCoinsAction, SIGNAL(triggered()), this, SLOT(gotoSendCoinsPage()));
	connect(receiveCoinsAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
	connect(receiveCoinsAction, SIGNAL(triggered()), this, SLOT(gotoReceiveCoinsPage()));
	connect(historyAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
	connect(historyAction, SIGNAL(triggered()), this, SLOT(gotoHistoryPage()));

	quitAction = new QAction(QIcon(":/icons/quit"), tr("E&xit"), this);
	quitAction->setStatusTip(tr("Quit application"));
	quitAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q));
	quitAction->setMenuRole(QAction::QuitRole);
	if (!fIsTestnet)
	aboutAction = new QAction(QIcon(":/icons/bitcoin"), tr("&About Bitcoin Core"), this);
	else
	aboutAction = new QAction(QIcon(":/icons/bitcoin_testnet"), tr("&About Bitcoin Core"), this);
	aboutAction->setStatusTip(tr("Show information about Bitcoin Core"));
	aboutAction->setMenuRole(QAction::AboutRole);
	#if QT_VERSION < 0x050000
	aboutQtAction = new QAction(QIcon(":/trolltech/qmessagebox/images/qtlogo-64.png"), tr("About &Qt"), this);
	#else
	aboutQtAction = new QAction(QIcon(":/qt-project.org/qmessagebox/images/qtlogo-64.png"), tr("About &Qt"), this);
	#endif
	aboutQtAction->setStatusTip(tr("Show information about Qt"));
	aboutQtAction->setMenuRole(QAction::AboutQtRole);
	optionsAction = new QAction(QIcon(":/icons/options"), tr("&Options..."), this);
	optionsAction->setStatusTip(tr("Modify configuration options for Bitcoin"));
	optionsAction->setMenuRole(QAction::PreferencesRole);
	if (!fIsTestnet)
	toggleHideAction = new QAction(QIcon(":/icons/bitcoin"), tr("&Show / Hide"), this);
	else
	toggleHideAction = new QAction(QIcon(":/icons/bitcoin_testnet"), tr("&Show / Hide"), this);
	toggleHideAction->setStatusTip(tr("Show or hide the main Window"));

	encryptWalletAction = new QAction(QIcon(":/icons/lock_closed"), tr("&Encrypt Wallet..."), this);
	encryptWalletAction->setStatusTip(tr("Encrypt the private keys that belong to your wallet"));
	encryptWalletAction->setCheckable(true);
	backupWalletAction = new QAction(QIcon(":/icons/filesave"), tr("&Backup Wallet..."), this);
	backupWalletAction->setStatusTip(tr("Backup wallet to another location"));
	changePassphraseAction = new QAction(QIcon(":/icons/key"), tr("&Change Passphrase..."), this);
	changePassphraseAction->setStatusTip(tr("Change the passphrase used for wallet encryption"));
	signMessageAction = new QAction(QIcon(":/icons/edit"), tr("Sign &message..."), this);
	signMessageAction->setStatusTip(tr("Sign messages with your Bitcoin addresses to prove you own them"));
	verifyMessageAction = new QAction(QIcon(":/icons/transaction_0"), tr("&Verify message..."), this);
	verifyMessageAction->setStatusTip(tr("Verify messages to ensure they were signed with specified Bitcoin addresses"));

	openRPCConsoleAction = new QAction(QIcon(":/icons/debugwindow"), tr("&Debug window"), this);
	openRPCConsoleAction->setStatusTip(tr("Open debugging and diagnostic console"));

	usedSendingAddressesAction = new QAction(QIcon(":/icons/address-book"), tr("&Sending addresses..."), this);
	usedSendingAddressesAction->setStatusTip(tr("Show the list of used sending addresses and labels"));
	usedReceivingAddressesAction = new QAction(QIcon(":/icons/address-book"), tr("&Receiving addresses..."), this);
	usedReceivingAddressesAction->setStatusTip(tr("Show the list of used receiving addresses and labels"));

	openAction = new QAction(QApplication::style()->standardIcon(QStyle::SP_FileIcon), tr("Open &URI..."), this);
	openAction->setStatusTip(tr("Open a bitcoin: URI or payment request"));

	showHelpMessageAction = new QAction(QApplication::style()->standardIcon(QStyle::SP_MessageBoxInformation), tr("&Command-line options"), this);
	showHelpMessageAction->setStatusTip(tr("Show the Bitcoin Core help message to get a list with possible Bitcoin command-line options"));

	connect(quitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
	connect(aboutAction, SIGNAL(triggered()), this, SLOT(aboutClicked()));
	connect(aboutQtAction, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
	connect(optionsAction, SIGNAL(triggered()), this, SLOT(optionsClicked()));
	connect(toggleHideAction, SIGNAL(triggered()), this, SLOT(toggleHidden()));
	connect(showHelpMessageAction, SIGNAL(triggered()), this, SLOT(showHelpMessageClicked()));
	#ifdef ENABLE_WALLET
	if(walletFrame)
	{
	connect(encryptWalletAction, SIGNAL(triggered(bool)), walletFrame, SLOT(encryptWallet(bool)));
	connect(backupWalletAction, SIGNAL(triggered()), walletFrame, SLOT(backupWallet()));
	connect(changePassphraseAction, SIGNAL(triggered()), walletFrame, SLOT(changePassphrase()));
	connect(signMessageAction, SIGNAL(triggered()), this, SLOT(gotoSignMessageTab()));
	connect(verifyMessageAction, SIGNAL(triggered()), this, SLOT(gotoVerifyMessageTab()));
	connect(usedSendingAddressesAction, SIGNAL(triggered()), walletFrame, SLOT(usedSendingAddresses()));
	connect(usedReceivingAddressesAction, SIGNAL(triggered()), walletFrame, SLOT(usedReceivingAddresses()));
	connect(openAction, SIGNAL(triggered()), this, SLOT(openClicked()));
	}
	#endif
	}

	void BitcoinGUI::createMenuBar()
	{
	#ifdef Q_OS_MAC
	// Create a decoupled menu bar on Mac which stays even if the window is closed
	appMenuBar = new QMenuBar();
	#else
	// Get the main window's menu bar on other platforms
	appMenuBar = menuBar();
	#endif

	// Configure the menus
	QMenu *file = appMenuBar->addMenu(tr("&File"));
	if(walletFrame)
	{
	file->addAction(openAction);
	file->addAction(backupWalletAction);
	file->addAction(signMessageAction);
	file->addAction(verifyMessageAction);
	file->addSeparator();
	file->addAction(usedSendingAddressesAction);
	file->addAction(usedReceivingAddressesAction);
	file->addSeparator();
	}
	file->addAction(quitAction);

	QMenu *settings = appMenuBar->addMenu(tr("&Settings"));
	if(walletFrame)
	{
	settings->addAction(encryptWalletAction);
	settings->addAction(changePassphraseAction);
	settings->addSeparator();
	}
	settings->addAction(optionsAction);

	QMenu *help = appMenuBar->addMenu(tr("&Help"));
	if(walletFrame)
	{
	help->addAction(openRPCConsoleAction);
	}
	help->addAction(showHelpMessageAction);
	help->addSeparator();
	help->addAction(aboutAction);
	help->addAction(aboutQtAction);
	}

	void BitcoinGUI::createToolBars()
	{
	if(walletFrame)
	{
	QToolBar *toolbar = addToolBar(tr("Tabs toolbar"));
	toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
	toolbar->addAction(overviewAction);
	toolbar->addAction(sendCoinsAction);
	toolbar->addAction(receiveCoinsAction);
	toolbar->addAction(historyAction);
	overviewAction->setChecked(true);
	}
	}

	void BitcoinGUI::setClientModel(ClientModel *clientModel)
	{
	this->clientModel = clientModel;
	if(clientModel)
	{
	// Create system tray menu (or setup the dock menu) that late to prevent users from calling actions,
	// while the client has not yet fully loaded
	createTrayIconMenu();

	// Keep up to date with client
	setNumConnections(clientModel->getNumConnections());
	connect(clientModel, SIGNAL(numConnectionsChanged(int)), this, SLOT(setNumConnections(int)));

	setNumBlocks(clientModel->getNumBlocks());
	connect(clientModel, SIGNAL(numBlocksChanged(int)), this, SLOT(setNumBlocks(int)));

	// Receive and report messages from client model
	connect(clientModel, SIGNAL(message(QString,QString,unsigned int)), this, SLOT(message(QString,QString,unsigned int)));

	// Show progress dialog
	connect(clientModel, SIGNAL(showProgress(QString,int)), this, SLOT(showProgress(QString,int)));

	rpcConsole->setClientModel(clientModel);
	#ifdef ENABLE_WALLET
	if(walletFrame)
	{
	walletFrame->setClientModel(clientModel);
	}
	#endif
	unitDisplayControl->setOptionsModel(clientModel->getOptionsModel());
	} else {
	// Disable possibility to show main window via action
	toggleHideAction->setEnabled(false);
	if(trayIconMenu)
	{
	// Disable context menu on tray icon
	trayIconMenu->clear();
	}
	}
	}

	#ifdef ENABLE_WALLET
	bool BitcoinGUI::addWallet(const QString& name, WalletModel *walletModel)
	{
	if(!walletFrame)
	return false;
	setWalletActionsEnabled(true);
	return walletFrame->addWallet(name, walletModel);
	}

	bool BitcoinGUI::setCurrentWallet(const QString& name)
	{
	if(!walletFrame)
	return false;
	return walletFrame->setCurrentWallet(name);
	}

	void BitcoinGUI::removeAllWallets()
	{
	if(!walletFrame)
	return;
	setWalletActionsEnabled(false);
	walletFrame->removeAllWallets();
	}
	#endif

	void BitcoinGUI::setWalletActionsEnabled(bool enabled)
	{
	overviewAction->setEnabled(enabled);
	sendCoinsAction->setEnabled(enabled);
	receiveCoinsAction->setEnabled(enabled);
	historyAction->setEnabled(enabled);
	encryptWalletAction->setEnabled(enabled);
	backupWalletAction->setEnabled(enabled);
	changePassphraseAction->setEnabled(enabled);
	signMessageAction->setEnabled(enabled);
	verifyMessageAction->setEnabled(enabled);
	usedSendingAddressesAction->setEnabled(enabled);
	usedReceivingAddressesAction->setEnabled(enabled);
	openAction->setEnabled(enabled);
	}

	void BitcoinGUI::createTrayIcon(bool fIsTestnet)
	{
	#ifndef Q_OS_MAC
	trayIcon = new QSystemTrayIcon(this);

	if (!fIsTestnet)
	{
	trayIcon->setToolTip(tr("Bitcoin Core client"));
	trayIcon->setIcon(QIcon(":/icons/bitcoin"));
	}
	else
	{
	trayIcon->setToolTip(tr("Bitcoin Core client") + " " + tr("[testnet]"));
	trayIcon->setIcon(QIcon(":/icons/bitcoin_testnet"));
	}

	trayIcon->show();
	#endif

	notificator = new Notificator(QApplication::applicationName(), trayIcon, this);
	}

	void BitcoinGUI::createTrayIconMenu()
	{
	#ifndef Q_OS_MAC
	// return if trayIcon is unset (only on non-Mac OSes)
	if (!trayIcon)
	return;

	trayIconMenu = new QMenu(this);
	trayIcon->setContextMenu(trayIconMenu);

	connect(trayIcon, SIGNAL(activated(QSystemTrayIcon::ActivationReason)),
	this, SLOT(trayIconActivated(QSystemTrayIcon::ActivationReason)));
	#else
	// Note: On Mac, the dock icon is used to provide the tray's functionality.
	MacDockIconHandler *dockIconHandler = MacDockIconHandler::instance();
	dockIconHandler->setMainWindow((QMainWindow *)this);
	trayIconMenu = dockIconHandler->dockMenu();
	#endif

	// Configuration of the tray icon (or dock icon) icon menu
	trayIconMenu->addAction(toggleHideAction);
	trayIconMenu->addSeparator();
	trayIconMenu->addAction(sendCoinsAction);
	trayIconMenu->addAction(receiveCoinsAction);
	trayIconMenu->addSeparator();
	trayIconMenu->addAction(signMessageAction);
	trayIconMenu->addAction(verifyMessageAction);
	trayIconMenu->addSeparator();
	trayIconMenu->addAction(optionsAction);
	trayIconMenu->addAction(openRPCConsoleAction);
	#ifndef Q_OS_MAC // This is built-in on Mac
	trayIconMenu->addSeparator();
	trayIconMenu->addAction(quitAction);
	#endif
	}

	#ifndef Q_OS_MAC
	void BitcoinGUI::trayIconActivated(QSystemTrayIcon::ActivationReason reason)
	{
	if(reason == QSystemTrayIcon::Trigger)
	{
	// Click on system tray icon triggers show/hide of the main window
	toggleHidden();
	}
	}
	#endif

	void BitcoinGUI::optionsClicked()
	{
	if(!clientModel \|\| !clientModel->getOptionsModel())
	return;

	OptionsDialog dlg(this);
	dlg.setModel(clientModel->getOptionsModel());
	dlg.exec();
	}

	void BitcoinGUI::aboutClicked()
	{
	if(!clientModel)
	return;

	HelpMessageDialog dlg(this, true);
	dlg.exec();
	}

	void BitcoinGUI::showHelpMessageClicked()
	{
	HelpMessageDialog *help = new HelpMessageDialog(this, false);
	help->setAttribute(Qt::WA_DeleteOnClose);
	help->show();
	}

	#ifdef ENABLE_WALLET
	void BitcoinGUI::openClicked()
	{
	OpenURIDialog dlg(this);
	if(dlg.exec())
	{
	emit receivedURI(dlg.getURI());
	}
	}

	void BitcoinGUI::gotoOverviewPage()
	{
	overviewAction->setChecked(true);
	if (walletFrame) walletFrame->gotoOverviewPage();
	}

	void BitcoinGUI::gotoHistoryPage()
	{
	historyAction->setChecked(true);
	if (walletFrame) walletFrame->gotoHistoryPage();
	}

	void BitcoinGUI::gotoReceiveCoinsPage()
	{
	receiveCoinsAction->setChecked(true);
	if (walletFrame) walletFrame->gotoReceiveCoinsPage();
	}

	void BitcoinGUI::gotoSendCoinsPage(QString addr)
	{
	sendCoinsAction->setChecked(true);
	if (walletFrame) walletFrame->gotoSendCoinsPage(addr);
	}

	void BitcoinGUI::gotoSignMessageTab(QString addr)
	{
	if (walletFrame) walletFrame->gotoSignMessageTab(addr);
	}

	void BitcoinGUI::gotoVerifyMessageTab(QString addr)
	{
	if (walletFrame) walletFrame->gotoVerifyMessageTab(addr);
	}
	#endif

	void BitcoinGUI::setNumConnections(int count)
	{
	QString icon;
	switch(count)
	{
	case 0: icon = ":/icons/connect_0"; break;
	case 1: case 2: case 3: icon = ":/icons/connect_1"; break;
	case 4: case 5: case 6: icon = ":/icons/connect_2"; break;
	case 7: case 8: case 9: icon = ":/icons/connect_3"; break;
	default: icon = ":/icons/connect_4"; break;
	}
	labelConnectionsIcon->setPixmap(QIcon(icon).pixmap(STATUSBAR_ICONSIZE,STATUSBAR_ICONSIZE));
	labelConnectionsIcon->setToolTip(tr("%n active connection(s) to Bitcoin network", "", count));
	}

	void BitcoinGUI::setNumBlocks(int count)
	{
	// Prevent orphan statusbar messages (e.g. hover Quit in main menu, wait until chain-sync starts -> garbelled text)
	statusBar()->clearMessage();

	// Acquire current block source
	enum BlockSource blockSource = clientModel->getBlockSource();
	switch (blockSource) {
	case BLOCK_SOURCE_NETWORK:
	progressBarLabel->setText(tr("Synchronizing with network..."));
	break;
	case BLOCK_SOURCE_DISK:
	progressBarLabel->setText(tr("Importing blocks from disk..."));
	break;
	case BLOCK_SOURCE_REINDEX:
	progressBarLabel->setText(tr("Reindexing blocks on disk..."));
	break;
	case BLOCK_SOURCE_NONE:
	// Case: not Importing, not Reindexing and no network connection
	progressBarLabel->setText(tr("No block source available..."));
	break;
	}

	QString tooltip;

	QDateTime lastBlockDate = clientModel->getLastBlockDate();
	QDateTime currentDate = QDateTime::currentDateTime();
	int secs = lastBlockDate.secsTo(currentDate);

	tooltip = tr("Processed %1 blocks of transaction history.").arg(count);

	// Set icon state: spinning if catching up, tick otherwise
	if(secs < 90*60)
	{
	tooltip = tr("Up to date") + QString(".<br>") + tooltip;
	labelBlocksIcon->setPixmap(QIcon(":/icons/synced").pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));

	#ifdef ENABLE_WALLET
	if(walletFrame)
	walletFrame->showOutOfSyncWarning(false);
	#endif

	progressBarLabel->setVisible(false);
	progressBar->setVisible(false);
	}
	else
	{
	// Represent time from last generated block in human readable text
	QString timeBehindText;
	const int HOUR_IN_SECONDS = 60*60;
	const int DAY_IN_SECONDS = 246060;
	const int WEEK_IN_SECONDS = 72460*60;
	const int YEAR_IN_SECONDS = 31556952; // Average length of year in Gregorian calendar
	if(secs < 2*DAY_IN_SECONDS)
	{
	timeBehindText = tr("%n hour(s)","",secs/HOUR_IN_SECONDS);
	}
	else if(secs < 2*WEEK_IN_SECONDS)
	{
	timeBehindText = tr("%n day(s)","",secs/DAY_IN_SECONDS);
	}
	else if(secs < YEAR_IN_SECONDS)
	{
	timeBehindText = tr("%n week(s)","",secs/WEEK_IN_SECONDS);
	}
	else
	{
	int years = secs / YEAR_IN_SECONDS;
	int remainder = secs % YEAR_IN_SECONDS;
	timeBehindText = tr("%1 and %2").arg(tr("%n year(s)", "", years)).arg(tr("%n week(s)","", remainder/WEEK_IN_SECONDS));
	}

	progressBarLabel->setVisible(true);
	progressBar->setFormat(tr("%1 behind").arg(timeBehindText));
	progressBar->setMaximum(1000000000);
	progressBar->setValue(clientModel->getVerificationProgress() * 1000000000.0 + 0.5);
	progressBar->setVisible(true);

	tooltip = tr("Catching up...") + QString("<br>") + tooltip;
	if(count != prevBlocks)
	{
	labelBlocksIcon->setPixmap(QIcon(QString(
	":/movies/spinner-%1").arg(spinnerFrame, 3, 10, QChar('0')))
	.pixmap(STATUSBAR_ICONSIZE, STATUSBAR_ICONSIZE));
	spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES;
	}
	prevBlocks = count;

	#ifdef ENABLE_WALLET
	if(walletFrame)
	walletFrame->showOutOfSyncWarning(true);
	#endif

	tooltip += QString("<br>");
	tooltip += tr("Last received block was generated %1 ago.").arg(timeBehindText);
	tooltip += QString("<br>");
	tooltip += tr("Transactions after this will not yet be visible.");
	}

	// Don't word-wrap this (fixed-width) tooltip
	tooltip = QString("<nobr>") + tooltip + QString("</nobr>");

	labelBlocksIcon->setToolTip(tooltip);
	progressBarLabel->setToolTip(tooltip);
	progressBar->setToolTip(tooltip);
	}

	void BitcoinGUI::message(const QString &title, const QString &message, unsigned int style, bool *ret)
	{
	QString strTitle = tr("Bitcoin"); // default title
	// Default to information icon
	int nMBoxIcon = QMessageBox::Information;
	int nNotifyIcon = Notificator::Information;

	QString msgType;

	// Prefer supplied title over style based title
	if (!title.isEmpty()) {
	msgType = title;
	}
	else {
	switch (style) {
	case CClientUIInterface::MSG_ERROR:
	msgType = tr("Error");
	break;
	case CClientUIInterface::MSG_WARNING:
	msgType = tr("Warning");
	break;
	case CClientUIInterface::MSG_INFORMATION:
	msgType = tr("Information");
	break;
	default:
	break;
	}
	}
	// Append title to "Bitcoin - "
	if (!msgType.isEmpty())
	strTitle += " - " + msgType;

	// Check for error/warning icon
	if (style & CClientUIInterface::ICON_ERROR) {
	nMBoxIcon = QMessageBox::Critical;
	nNotifyIcon = Notificator::Critical;
	}
	else if (style & CClientUIInterface::ICON_WARNING) {
	nMBoxIcon = QMessageBox::Warning;
	nNotifyIcon = Notificator::Warning;
	}

	// Display message
	if (style & CClientUIInterface::MODAL) {
	// Check for buttons, use OK as default, if none was supplied
	QMessageBox::StandardButton buttons;
	if (!(buttons = (QMessageBox::StandardButton)(style & CClientUIInterface::BTN_MASK)))
	buttons = QMessageBox::Ok;

	showNormalIfMinimized();
	QMessageBox mBox((QMessageBox::Icon)nMBoxIcon, strTitle, message, buttons, this);
	int r = mBox.exec();
	if (ret != NULL)
	*ret = r == QMessageBox::Ok;
	}
	else
	notificator->notify((Notificator::Class)nNotifyIcon, strTitle, message);
	}

	void BitcoinGUI::changeEvent(QEvent *e)
	{
	QMainWindow::changeEvent(e);
	#ifndef Q_OS_MAC // Ignored on Mac
	if(e->type() == QEvent::WindowStateChange)
	{
	if(clientModel && clientModel->getOptionsModel()->getMinimizeToTray())
	{
	QWindowStateChangeEvent wsevt = static_cast<QWindowStateChangeEvent>(e);
	if(!(wsevt->oldState() & Qt::WindowMinimized) && isMinimized())
	{
	QTimer::singleShot(0, this, SLOT(hide()));
	e->ignore();
	}
	}
	}
	#endif
	}

	void BitcoinGUI::closeEvent(QCloseEvent *event)
	{
	if(clientModel)
	{
	#ifndef Q_OS_MAC // Ignored on Mac
	if(!clientModel->getOptionsModel()->getMinimizeToTray() &&
	!clientModel->getOptionsModel()->getMinimizeOnClose())
	{
	QApplication::quit();
	}
	#endif
	}
	QMainWindow::closeEvent(event);
	}

	#ifdef ENABLE_WALLET
	void BitcoinGUI::incomingTransaction(const QString& date, int unit, qint64 amount, const QString& type, const QString& address)
	{
	// On new transaction, make an info balloon
	message((amount)<0 ? tr("Sent transaction") : tr("Incoming transaction"),
	tr("Date: %1\n"
	"Amount: %2\n"
	"Type: %3\n"
	"Address: %4\n")
	.arg(date)
	.arg(BitcoinUnits::formatWithUnit(unit, amount, true))
	.arg(type)
	.arg(address), CClientUIInterface::MSG_INFORMATION);
	}
	#endif

	void BitcoinGUI::dragEnterEvent(QDragEnterEvent *event)
	{
	// Accept only URIs
	if(event->mimeData()->hasUrls())
	event->acceptProposedAction();
	}

	void BitcoinGUI::dropEvent(QDropEvent *event)
	{
	if(event->mimeData()->hasUrls())
	{
	foreach(const QUrl &uri, event->mimeData()->urls())
	{
	emit receivedURI(uri.toString());
	}
	}
	event->acceptProposedAction();
	}

	bool BitcoinGUI::eventFilter(QObject object, QEvent event)
	{
	// Catch status tip events
	if (event->type() == QEvent::StatusTip)
	{
	// Prevent adding text from setStatusTip(), if we currently use the status bar for displaying other stuff
	if (progressBarLabel->isVisible() \|\| progressBar->isVisible())
	return true;
	}
	return QMainWindow::eventFilter(object, event);
	}

	#ifdef ENABLE_WALLET
	bool BitcoinGUI::handlePaymentRequest(const SendCoinsRecipient& recipient)
	{
	// URI has to be valid
	if (walletFrame && walletFrame->handlePaymentRequest(recipient))
	{
	showNormalIfMinimized();
	gotoSendCoinsPage();
	return true;
	}
	else
	return false;
	}

	void BitcoinGUI::setEncryptionStatus(int status)
	{
	switch(status)
	{
	case WalletModel::Unencrypted:
	labelEncryptionIcon->hide();
	encryptWalletAction->setChecked(false);
	changePassphraseAction->setEnabled(false);
	encryptWalletAction->setEnabled(true);
	break;
	case WalletModel::Unlocked:
	labelEncryptionIcon->show();
	labelEncryptionIcon->setPixmap(QIcon(":/icons/lock_open").pixmap(STATUSBAR_ICONSIZE,STATUSBAR_ICONSIZE));
	labelEncryptionIcon->setToolTip(tr("Wallet is <b>encrypted</b> and currently <b>unlocked</b>"));
	encryptWalletAction->setChecked(true);
	changePassphraseAction->setEnabled(true);
	encryptWalletAction->setEnabled(false); // TODO: decrypt currently not supported
	break;
	case WalletModel::Locked:
	labelEncryptionIcon->show();
	labelEncryptionIcon->setPixmap(QIcon(":/icons/lock_closed").pixmap(STATUSBAR_ICONSIZE,STATUSBAR_ICONSIZE));
	labelEncryptionIcon->setToolTip(tr("Wallet is <b>encrypted</b> and currently <b>locked</b>"));
	encryptWalletAction->setChecked(true);
	changePassphraseAction->setEnabled(true);
	encryptWalletAction->setEnabled(false); // TODO: decrypt currently not supported
	break;
	}
	}
	#endif

	void BitcoinGUI::showNormalIfMinimized(bool fToggleHidden)
	{
	if(!clientModel)
	return;

	// activateWindow() (sometimes) helps with keyboard focus on Windows
	if (isHidden())
	{
	show();
	activateWindow();
	}
	else if (isMinimized())
	{
	showNormal();
	activateWindow();
	}
	else if (GUIUtil::isObscured(this))
	{
	raise();
	activateWindow();
	}
	else if(fToggleHidden)
	hide();
	}

	void BitcoinGUI::toggleHidden()
	{
	showNormalIfMinimized(true);
	}

	void BitcoinGUI::detectShutdown()
	{
	if (ShutdownRequested())
	{
	if(rpcConsole)
	rpcConsole->hide();
	qApp->quit();
	}
	}

	void BitcoinGUI::showProgress(const QString &title, int nProgress)
	{
	if (nProgress == 0)
	{
	progressDialog = new QProgressDialog(title, "", 0, 100);
	progressDialog->setWindowModality(Qt::ApplicationModal);
	progressDialog->setMinimumDuration(0);
	progressDialog->setCancelButton(0);
	progressDialog->setAutoClose(false);
	progressDialog->setValue(0);
	}
	else if (nProgress == 100)
	{
	if (progressDialog)
	{
	progressDialog->close();
	progressDialog->deleteLater();
	}
	}
	else if (progressDialog)
	progressDialog->setValue(nProgress);
	}

	static bool ThreadSafeMessageBox(BitcoinGUI *gui, const std::string& message, const std::string& caption, unsigned int style)
	{
	bool modal = (style & CClientUIInterface::MODAL);
	bool ret = false;
	// In case of modal message, use blocking connection to wait for user to click a button
	QMetaObject::invokeMethod(gui, "message",
	modal ? GUIUtil::blockingGUIThreadConnection() : Qt::QueuedConnection,
	Q_ARG(QString, QString::fromStdString(caption)),
	Q_ARG(QString, QString::fromStdString(message)),
	Q_ARG(unsigned int, style),
	Q_ARG(bool*, &ret));
	return ret;
	}

	void BitcoinGUI::subscribeToCoreSignals()
	{
	// Connect signals to client
	uiInterface.ThreadSafeMessageBox.connect(boost::bind(ThreadSafeMessageBox, this, _1, _2, _3));
	}

	void BitcoinGUI::unsubscribeFromCoreSignals()
	{
	// Disconnect signals from client
	uiInterface.ThreadSafeMessageBox.disconnect(boost::bind(ThreadSafeMessageBox, this, _1, _2, _3));
	}

	UnitDisplayStatusBarControl::UnitDisplayStatusBarControl() :
	optionsModel(0),
	menu(0)
	{
	createContextMenu();
	setToolTip(tr("Unit to show amounts in. Click to select another unit."));
	}

	/** So that it responds to button clicks */
	void UnitDisplayStatusBarControl::mousePressEvent(QMouseEvent *event)
	{
	onDisplayUnitsClicked(event->pos());
	}

	/** Creates context menu, its actions, and wires up all the relevant signals for mouse events. */
	void UnitDisplayStatusBarControl::createContextMenu()
	{
	menu = new QMenu();
	foreach(BitcoinUnits::Unit u, BitcoinUnits::availableUnits())
	{
	QAction *menuAction = new QAction(QString(BitcoinUnits::name(u)), this);
	menuAction->setData(QVariant(u));
	menu->addAction(menuAction);
	}
	connect(menu,SIGNAL(triggered(QAction)),this,SLOT(onMenuSelection(QAction)));
	}

	/** Lets the control know about the Options Model (and its signals) */
	void UnitDisplayStatusBarControl::setOptionsModel(OptionsModel *optionsModel)
	{
	if (optionsModel)
	{
	this->optionsModel = optionsModel;

	// be aware of a display unit change reported by the OptionsModel object.
	connect(optionsModel,SIGNAL(displayUnitChanged(int)),this,SLOT(updateDisplayUnit(int)));

	// initialize the display units label with the current value in the model.
	updateDisplayUnit(optionsModel->getDisplayUnit());
	}
	}

	/** When Display Units are changed on OptionsModel it will refresh the display text of the control on the status bar */
	void UnitDisplayStatusBarControl::updateDisplayUnit(int newUnits)
	{
	setPixmap(QIcon(":/icons/unit_" + BitcoinUnits::id(newUnits)).pixmap(31,STATUSBAR_ICONSIZE));
	}

	/** Shows context menu with Display Unit options by the mouse coordinates */
	void UnitDisplayStatusBarControl::onDisplayUnitsClicked(const QPoint& point)
	{
	QPoint globalPos = mapToGlobal(point);
	menu->exec(globalPos);
	}

	/** Tells underlying optionsModel to update its current display unit. */
	void UnitDisplayStatusBarControl::onMenuSelection(QAction* action)
	{
	if (action)
	{
	optionsModel->setDisplayUnit(action->data());
	}
	}
	diff --git a/src/qt/coincontroldialog.h b/src/qt/coincontroldialog.h
	index 4f7422642f..a6f239a898 100644
	--- a/src/qt/coincontroldialog.h
	+++ b/src/qt/coincontroldialog.h
	@@ -1,123 +1,125 @@
	// 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 COINCONTROLDIALOG_H
	#define COINCONTROLDIALOG_H

	#include <QAbstractButton>
	#include <QAction>
	#include <QDialog>
	#include <QList>
	#include <QMenu>
	#include <QPoint>
	#include <QString>
	#include <QTreeWidgetItem>

	-namespace Ui {
	- class CoinControlDialog;
	-}
	class WalletModel;
	+
	class CCoinControl;
	class CTxMemPool;

	+namespace Ui {
	+ class CoinControlDialog;
	+}
	+
	class CoinControlDialog : public QDialog
	{
	Q_OBJECT

	public:
	explicit CoinControlDialog(QWidget *parent = 0);
	~CoinControlDialog();

	void setModel(WalletModel *model);

	// static because also called from sendcoinsdialog
	static void updateLabels(WalletModel, QDialog);
	static QString getPriorityLabel(const CTxMemPool& pool, double);

	static QList<qint64> payAmounts;
	static CCoinControl *coinControl;

	private:
	Ui::CoinControlDialog *ui;
	WalletModel *model;
	int sortColumn;
	Qt::SortOrder sortOrder;

	QMenu *contextMenu;
	QTreeWidgetItem *contextMenuItem;
	QAction *copyTransactionHashAction;
	QAction *lockAction;
	QAction *unlockAction;

	QString strPad(QString, int, QString);
	void sortView(int, Qt::SortOrder);
	void updateView();

	enum
	{
	COLUMN_CHECKBOX,
	COLUMN_AMOUNT,
	COLUMN_LABEL,
	COLUMN_ADDRESS,
	COLUMN_DATE,
	COLUMN_CONFIRMATIONS,
	COLUMN_PRIORITY,
	COLUMN_TXHASH,
	COLUMN_VOUT_INDEX,
	COLUMN_AMOUNT_INT64,
	COLUMN_PRIORITY_INT64,
	COLUMN_DATE_INT64
	};

	// some columns have a hidden column containing the value used for sorting
	int getMappedColumn(int column, bool fVisibleColumn = true)
	{
	if (fVisibleColumn)
	{
	if (column == COLUMN_AMOUNT_INT64)
	return COLUMN_AMOUNT;
	else if (column == COLUMN_PRIORITY_INT64)
	return COLUMN_PRIORITY;
	else if (column == COLUMN_DATE_INT64)
	return COLUMN_DATE;
	}
	else
	{
	if (column == COLUMN_AMOUNT)
	return COLUMN_AMOUNT_INT64;
	else if (column == COLUMN_PRIORITY)
	return COLUMN_PRIORITY_INT64;
	else if (column == COLUMN_DATE)
	return COLUMN_DATE_INT64;
	}

	return column;
	}

	private slots:
	void showMenu(const QPoint &);
	void copyAmount();
	void copyLabel();
	void copyAddress();
	void copyTransactionHash();
	void lockCoin();
	void unlockCoin();
	void clipboardQuantity();
	void clipboardAmount();
	void clipboardFee();
	void clipboardAfterFee();
	void clipboardBytes();
	void clipboardPriority();
	void clipboardLowOutput();
	void clipboardChange();
	void radioTreeMode(bool);
	void radioListMode(bool);
	void viewItemChanged(QTreeWidgetItem*, int);
	void headerSectionClicked(int);
	void buttonBoxClicked(QAbstractButton*);
	void buttonSelectAllClicked();
	void updateLabelLocked();
	};

	#endif // COINCONTROLDIALOG_H
	diff --git a/src/qt/intro.h b/src/qt/intro.h
	index 295a75562f..e3e396d369 100644
	--- a/src/qt/intro.h
	+++ b/src/qt/intro.h
	@@ -1,73 +1,73 @@
	// 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 INTRO_H
	#define INTRO_H

	#include <QDialog>
	#include <QMutex>
	#include <QThread>

	class FreespaceChecker;

	namespace Ui {
	-class Intro;
	+ class Intro;
	}

	/** Introduction screen (pre-GUI startup).
	Allows the user to choose a data directory,
	in which the wallet and block chain will be stored.
	*/
	class Intro : public QDialog
	{
	Q_OBJECT

	public:
	explicit Intro(QWidget *parent = 0);
	~Intro();

	QString getDataDirectory();
	void setDataDirectory(const QString &dataDir);

	/**
	* Determine data directory. Let the user choose if the current one doesn't exist.
	*
	* @note do NOT call global GetDataDir() before calling this function, this
	* will cause the wrong path to be cached.
	*/
	static void pickDataDirectory();

	/**
	* Determine default data directory for operating system.
	*/
	static QString getDefaultDataDirectory();

	signals:
	void requestCheck();
	void stopThread();

	public slots:
	void setStatus(int status, const QString &message, quint64 bytesAvailable);

	private slots:
	void on_dataDirectory_textChanged(const QString &arg1);
	void on_ellipsisButton_clicked();
	void on_dataDirDefault_clicked();
	void on_dataDirCustom_clicked();

	private:
	Ui::Intro *ui;
	QThread *thread;
	QMutex mutex;
	bool signalled;
	QString pathToCheck;

	void startThread();
	void checkPath(const QString &dataDir);
	QString getPathToCheck();

	friend class FreespaceChecker;
	};

	#endif // INTRO_H
	diff --git a/src/qt/openuridialog.h b/src/qt/openuridialog.h
	index 28da7d6d9d..67a5f167d1 100644
	--- a/src/qt/openuridialog.h
	+++ b/src/qt/openuridialog.h
	@@ -1,34 +1,34 @@
	// 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 OPENURIDIALOG_H
	#define OPENURIDIALOG_H

	#include <QDialog>

	namespace Ui {
	-class OpenURIDialog;
	+ class OpenURIDialog;
	}

	class OpenURIDialog : public QDialog
	{
	Q_OBJECT

	public:
	explicit OpenURIDialog(QWidget *parent);
	~OpenURIDialog();

	QString getURI();

	protected slots:
	void accept();

	private slots:
	void on_selectFileButton_clicked();

	private:
	Ui::OpenURIDialog *ui;
	};

	#endif // OPENURIDIALOG_H
	diff --git a/src/qt/optionsdialog.cpp b/src/qt/optionsdialog.cpp
	index c775a7f8d6..279467129f 100644
	--- a/src/qt/optionsdialog.cpp
	+++ b/src/qt/optionsdialog.cpp
	@@ -1,301 +1,303 @@
	// 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 "config/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 MAX_SCRIPTCHECK_THREADS
	#include "netbase.h"
	#include "txdb.h" // for -dbcache defaults
	+
	#ifdef ENABLE_WALLET
	#include "wallet.h" // for CWallet::minTxFee
	#endif

	#include <boost/thread.hpp>
	+
	#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));

	connect(ui->connectSocks, SIGNAL(toggled(bool)), ui->proxyIp, SLOT(setEnabled(bool)));
	connect(ui->connectSocks, SIGNAL(toggled(bool)), ui->proxyPort, 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));
	#ifdef ENABLE_WALLET
	ui->transactionFee->setSingleStep(CWallet::minTxFee.GetFeePerK());
	#endif

	/* 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->allowIncoming, SIGNAL(clicked(bool)), this, SLOT(showRestartWarning()));
	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->allowIncoming, OptionsModel::Listen);

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

	/* 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->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 99928ebe4d..bd747faeb6 100644
	--- a/src/qt/optionsmodel.cpp
	+++ b/src/qt/optionsmodel.cpp
	@@ -1,379 +1,380 @@
	// 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 "config/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("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", (qint64)DEFAULT_TRANSACTION_FEE);
	payTxFee = CFeeRate(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"))
	settings.setValue("fUseUPnP", DEFAULT_UPNP);
	if (!SoftSetBoolArg("-upnp", settings.value("fUseUPnP").toBool()))
	addOverriddenOption("-upnp");

	if (!settings.contains("fListen"))
	settings.setValue("fListen", DEFAULT_LISTEN);
	if (!SoftSetBoolArg("-listen", settings.value("fListen").toBool()))
	addOverriddenOption("-listen");

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

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

	#ifdef ENABLE_WALLET
	case Fee: {
	// Attention: Init() is called before payTxFee 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 (!(payTxFee == CFeeRate(settings.value("nTransactionFee").toLongLong(), 1000)))
	settings.setValue("nTransactionFee", (qint64)payTxFee.GetFeePerK());
	// Todo: Consider to revert back to use just payTxFee 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 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");
	case Listen:
	return settings.value("fListen");
	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;
	#ifdef ENABLE_WALLET
	case Fee: { // core option - can be changed on-the-fly
	// Todo: Add is valid check and warn via message, if not
	qint64 nTransactionFee = value.toLongLong();
	payTxFee = CFeeRate(nTransactionFee, 1000);
	settings.setValue("nTransactionFee", nTransactionFee);
	emit transactionFeeChanged(nTransactionFee);
	break;
	}
	case SpendZeroConfChange:
	if (settings.value("bSpendZeroConfChange") != value) {
	settings.setValue("bSpendZeroConfChange", value);
	setRestartRequired(true);
	}
	break;
	#endif
	case DisplayUnit:
	setDisplayUnit(value);
	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;
	case Listen:
	if (settings.value("fListen") != value) {
	settings.setValue("fListen", value);
	setRestartRequired(true);
	}
	break;
	default:
	break;
	}
	}

	emit dataChanged(index, index);

	return successful;
	}

	/** Updates current unit in memory, settings and emits displayUnitChanged(newUnit) signal */
	void OptionsModel::setDisplayUnit(const QVariant &value)
	{
	if (!value.isNull())
	{
	QSettings settings;
	nDisplayUnit = value.toInt();
	settings.setValue("nDisplayUnit", nDisplayUnit);
	emit displayUnitChanged(nDisplayUnit);
	}
	}

	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)) {
	proxy.setType(QNetworkProxy::Socks5Proxy);
	proxy.setHostName(QString::fromStdString(curProxy.ToStringIP()));
	proxy.setPort(curProxy.GetPort());

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

	return false;
	}

	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/paymentrequestplus.cpp b/src/qt/paymentrequestplus.cpp
	index acce42e203..7b7de49831 100644
	--- a/src/qt/paymentrequestplus.cpp
	+++ b/src/qt/paymentrequestplus.cpp
	@@ -1,209 +1,210 @@
	// 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.

	//
	// Wraps dumb protocol buffer paymentRequest
	// with some extra methods
	//

	#include "paymentrequestplus.h"

	#include <stdexcept>

	#include <openssl/x509.h>
	#include <openssl/x509_vfy.h>
	+
	#include <QDateTime>
	#include <QDebug>
	#include <QSslCertificate>

	using namespace std;

	class SSLVerifyError : public std::runtime_error
	{
	public:
	SSLVerifyError(std::string err) : std::runtime_error(err) { }
	};

	bool PaymentRequestPlus::parse(const QByteArray& data)
	{
	bool parseOK = paymentRequest.ParseFromArray(data.data(), data.size());
	if (!parseOK) {
	qWarning() << "PaymentRequestPlus::parse : Error parsing payment request";
	return false;
	}
	if (paymentRequest.payment_details_version() > 1) {
	qWarning() << "PaymentRequestPlus::parse : Received up-version payment details, version=" << paymentRequest.payment_details_version();
	return false;
	}

	parseOK = details.ParseFromString(paymentRequest.serialized_payment_details());
	if (!parseOK)
	{
	qWarning() << "PaymentRequestPlus::parse : Error parsing payment details";
	paymentRequest.Clear();
	return false;
	}
	return true;
	}

	bool PaymentRequestPlus::SerializeToString(string* output) const
	{
	return paymentRequest.SerializeToString(output);
	}

	bool PaymentRequestPlus::IsInitialized() const
	{
	return paymentRequest.IsInitialized();
	}

	QString PaymentRequestPlus::getPKIType() const
	{
	if (!IsInitialized()) return QString("none");
	return QString::fromStdString(paymentRequest.pki_type());
	}

	bool PaymentRequestPlus::getMerchant(X509_STORE* certStore, QString& merchant) const
	{
	merchant.clear();

	if (!IsInitialized())
	return false;

	// One day we'll support more PKI types, but just
	// x509 for now:
	const EVP_MD* digestAlgorithm = NULL;
	if (paymentRequest.pki_type() == "x509+sha256") {
	digestAlgorithm = EVP_sha256();
	}
	else if (paymentRequest.pki_type() == "x509+sha1") {
	digestAlgorithm = EVP_sha1();
	}
	else if (paymentRequest.pki_type() == "none") {
	qWarning() << "PaymentRequestPlus::getMerchant : Payment request: pki_type == none";
	return false;
	}
	else {
	qWarning() << "PaymentRequestPlus::getMerchant : Payment request: unknown pki_type " << QString::fromStdString(paymentRequest.pki_type());
	return false;
	}

	payments::X509Certificates certChain;
	if (!certChain.ParseFromString(paymentRequest.pki_data())) {
	qWarning() << "PaymentRequestPlus::getMerchant : Payment request: error parsing pki_data";
	return false;
	}

	std::vector<X509*> certs;
	const QDateTime currentTime = QDateTime::currentDateTime();
	for (int i = 0; i < certChain.certificate_size(); i++) {
	QByteArray certData(certChain.certificate(i).data(), certChain.certificate(i).size());
	QSslCertificate qCert(certData, QSsl::Der);
	if (currentTime < qCert.effectiveDate() \|\| currentTime > qCert.expiryDate()) {
	qWarning() << "PaymentRequestPlus::getMerchant : Payment request: certificate expired or not yet active: " << qCert;
	return false;
	}
	#if QT_VERSION >= 0x050000
	if (qCert.isBlacklisted()) {
	qWarning() << "PaymentRequestPlus::getMerchant : Payment request: certificate blacklisted: " << qCert;
	return false;
	}
	#endif
	const unsigned char data = (const unsigned char )certChain.certificate(i).data();
	X509 *cert = d2i_X509(NULL, &data, certChain.certificate(i).size());
	if (cert)
	certs.push_back(cert);
	}
	if (certs.empty()) {
	qWarning() << "PaymentRequestPlus::getMerchant : Payment request: empty certificate chain";
	return false;
	}

	// The first cert is the signing cert, the rest are untrusted certs that chain
	// to a valid root authority. OpenSSL needs them separately.
	STACK_OF(X509) *chain = sk_X509_new_null();
	for (int i = certs.size()-1; i > 0; i--) {
	sk_X509_push(chain, certs[i]);
	}
	X509 *signing_cert = certs[0];

	// Now create a "store context", which is a single use object for checking,
	// load the signing cert into it and verify.
	X509_STORE_CTX *store_ctx = X509_STORE_CTX_new();
	if (!store_ctx) {
	qWarning() << "PaymentRequestPlus::getMerchant : Payment request: error creating X509_STORE_CTX";
	return false;
	}

	char *website = NULL;
	bool fResult = true;
	try
	{
	if (!X509_STORE_CTX_init(store_ctx, certStore, signing_cert, chain))
	{
	int error = X509_STORE_CTX_get_error(store_ctx);
	throw SSLVerifyError(X509_verify_cert_error_string(error));
	}

	// Now do the verification!
	int result = X509_verify_cert(store_ctx);
	if (result != 1) {
	int error = X509_STORE_CTX_get_error(store_ctx);
	throw SSLVerifyError(X509_verify_cert_error_string(error));
	}
	X509_NAME *certname = X509_get_subject_name(signing_cert);

	// Valid cert; check signature:
	payments::PaymentRequest rcopy(paymentRequest); // Copy
	rcopy.set_signature(std::string(""));
	std::string data_to_verify; // Everything but the signature
	rcopy.SerializeToString(&data_to_verify);

	EVP_MD_CTX ctx;
	EVP_PKEY *pubkey = X509_get_pubkey(signing_cert);
	EVP_MD_CTX_init(&ctx);
	if (!EVP_VerifyInit_ex(&ctx, digestAlgorithm, NULL) \|\|
	!EVP_VerifyUpdate(&ctx, data_to_verify.data(), data_to_verify.size()) \|\|
	!EVP_VerifyFinal(&ctx, (const unsigned char*)paymentRequest.signature().data(), paymentRequest.signature().size(), pubkey)) {

	throw SSLVerifyError("Bad signature, invalid PaymentRequest.");
	}

	// OpenSSL API for getting human printable strings from certs is baroque.
	int textlen = X509_NAME_get_text_by_NID(certname, NID_commonName, NULL, 0);
	website = new char[textlen + 1];
	if (X509_NAME_get_text_by_NID(certname, NID_commonName, website, textlen + 1) == textlen && textlen > 0) {
	merchant = website;
	}
	else {
	throw SSLVerifyError("Bad certificate, missing common name.");
	}
	// TODO: detect EV certificates and set merchant = business name instead of unfriendly NID_commonName ?
	}
	catch (SSLVerifyError& err)
	{
	fResult = false;
	qWarning() << "PaymentRequestPlus::getMerchant : SSL error: " << err.what();
	}

	if (website)
	delete[] website;
	X509_STORE_CTX_free(store_ctx);
	for (unsigned int i = 0; i < certs.size(); i++)
	X509_free(certs[i]);

	return fResult;
	}

	QList<std::pair<CScript,qint64> > PaymentRequestPlus::getPayTo() const
	{
	QList<std::pair<CScript,qint64> > result;
	for (int i = 0; i < details.outputs_size(); i++)
	{
	const unsigned char* scriptStr = (const unsigned char*)details.outputs(i).script().data();
	CScript s(scriptStr, scriptStr+details.outputs(i).script().size());

	result.append(make_pair(s, details.outputs(i).amount()));
	}
	return result;
	}
	diff --git a/src/qt/receivecoinsdialog.h b/src/qt/receivecoinsdialog.h
	index 663cb157a4..7a7e38e25e 100644
	--- a/src/qt/receivecoinsdialog.h
	+++ b/src/qt/receivecoinsdialog.h
	@@ -1,75 +1,76 @@
	// 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.

	#ifndef RECEIVECOINSDIALOG_H
	#define RECEIVECOINSDIALOG_H

	+#include "guiutil.h"
	+
	#include <QDialog>
	#include <QHeaderView>
	#include <QItemSelection>
	#include <QKeyEvent>
	#include <QMenu>
	#include <QPoint>
	#include <QVariant>

	-#include "guiutil.h"
	+class OptionsModel;
	+class WalletModel;

	namespace Ui {
	class ReceiveCoinsDialog;
	}
	-class OptionsModel;
	-class WalletModel;

	QT_BEGIN_NAMESPACE
	class QModelIndex;
	QT_END_NAMESPACE

	/** Dialog for requesting payment of bitcoins */
	class ReceiveCoinsDialog : public QDialog
	{
	Q_OBJECT

	public:
	enum ColumnWidths {
	DATE_COLUMN_WIDTH = 130,
	LABEL_COLUMN_WIDTH = 120,
	AMOUNT_MINIMUM_COLUMN_WIDTH = 160,
	MINIMUM_COLUMN_WIDTH = 130
	};

	explicit ReceiveCoinsDialog(QWidget *parent = 0);
	~ReceiveCoinsDialog();

	void setModel(WalletModel *model);

	public slots:
	void clear();
	void reject();
	void accept();

	protected:
	virtual void keyPressEvent(QKeyEvent *event);

	private:
	Ui::ReceiveCoinsDialog *ui;
	GUIUtil::TableViewLastColumnResizingFixer *columnResizingFixer;
	WalletModel *model;
	QMenu *contextMenu;
	void copyColumnToClipboard(int column);
	virtual void resizeEvent(QResizeEvent *event);

	private slots:
	void on_receiveButton_clicked();
	void on_showRequestButton_clicked();
	void on_removeRequestButton_clicked();
	void on_recentRequestsView_doubleClicked(const QModelIndex &index);
	void recentRequestsView_selectionChanged(const QItemSelection &selected, const QItemSelection &deselected);
	void updateDisplayUnit();
	void showMenu(const QPoint &point);
	void copyLabel();
	void copyMessage();
	void copyAmount();
	};

	#endif // RECEIVECOINSDIALOG_H
	diff --git a/src/qt/rpcconsole.cpp b/src/qt/rpcconsole.cpp
	index 11089b2497..8129353d4b 100644
	--- a/src/qt/rpcconsole.cpp
	+++ b/src/qt/rpcconsole.cpp
	@@ -1,658 +1,660 @@
	// 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 "rpcconsole.h"
	#include "ui_rpcconsole.h"

	#include "clientmodel.h"
	#include "guiutil.h"
	#include "peertablemodel.h"

	#include "main.h"
	#include "chainparams.h"
	#include "rpcserver.h"
	#include "rpcclient.h"
	#include "util.h"

	#include "json/json_spirit_value.h"
	+
	+#include <openssl/crypto.h>
	+
	#ifdef ENABLE_WALLET
	#include <db_cxx.h>
	#endif
	-#include <openssl/crypto.h>

	#include <QKeyEvent>
	#include <QScrollBar>
	#include <QThread>
	#include <QTime>

	#if QT_VERSION < 0x050000
	#include <QUrl>
	#endif

	// TODO: add a scrollback limit, as there is currently none
	// TODO: make it possible to filter out categories (esp debug messages when implemented)
	// TODO: receive errors and debug messages through ClientModel

	const int CONSOLE_HISTORY = 50;
	const QSize ICON_SIZE(24, 24);

	const int INITIAL_TRAFFIC_GRAPH_MINS = 30;

	const struct {
	const char *url;
	const char *source;
	} ICON_MAPPING[] = {
	{"cmd-request", ":/icons/tx_input"},
	{"cmd-reply", ":/icons/tx_output"},
	{"cmd-error", ":/icons/tx_output"},
	{"misc", ":/icons/tx_inout"},
	{NULL, NULL}
	};

	/* Object for executing console RPC commands in a separate thread.
	*/
	class RPCExecutor : public QObject
	{
	Q_OBJECT

	public slots:
	void request(const QString &command);

	signals:
	void reply(int category, const QString &command);
	};

	#include "rpcconsole.moc"

	/**
	* Split shell command line into a list of arguments. Aims to emulate \c bash and friends.
	*
	* - Arguments are delimited with whitespace
	* - Extra whitespace at the beginning and end and between arguments will be ignored
	* - Text can be "double" or 'single' quoted
	* - The backslash \c \ is used as escape character
	* - Outside quotes, any character can be escaped
	* - Within double quotes, only escape \c " and backslashes before a \c " or another backslash
	* - Within single quotes, no escaping is possible and no special interpretation takes place
	*
	* @param[out] args Parsed arguments will be appended to this list
	* @param[in] strCommand Command line to split
	*/
	bool parseCommandLine(std::vector<std::string> &args, const std::string &strCommand)
	{
	enum CmdParseState
	{
	STATE_EATING_SPACES,
	STATE_ARGUMENT,
	STATE_SINGLEQUOTED,
	STATE_DOUBLEQUOTED,
	STATE_ESCAPE_OUTER,
	STATE_ESCAPE_DOUBLEQUOTED
	} state = STATE_EATING_SPACES;
	std::string curarg;
	foreach(char ch, strCommand)
	{
	switch(state)
	{
	case STATE_ARGUMENT: // In or after argument
	case STATE_EATING_SPACES: // Handle runs of whitespace
	switch(ch)
	{
	case '"': state = STATE_DOUBLEQUOTED; break;
	case '\'': state = STATE_SINGLEQUOTED; break;
	case '\\': state = STATE_ESCAPE_OUTER; break;
	case ' ': case '\n': case '\t':
	if(state == STATE_ARGUMENT) // Space ends argument
	{
	args.push_back(curarg);
	curarg.clear();
	}
	state = STATE_EATING_SPACES;
	break;
	default: curarg += ch; state = STATE_ARGUMENT;
	}
	break;
	case STATE_SINGLEQUOTED: // Single-quoted string
	switch(ch)
	{
	case '\'': state = STATE_ARGUMENT; break;
	default: curarg += ch;
	}
	break;
	case STATE_DOUBLEQUOTED: // Double-quoted string
	switch(ch)
	{
	case '"': state = STATE_ARGUMENT; break;
	case '\\': state = STATE_ESCAPE_DOUBLEQUOTED; break;
	default: curarg += ch;
	}
	break;
	case STATE_ESCAPE_OUTER: // '\' outside quotes
	curarg += ch; state = STATE_ARGUMENT;
	break;
	case STATE_ESCAPE_DOUBLEQUOTED: // '\' in double-quoted text
	if(ch != '"' && ch != '\\') curarg += '\\'; // keep '\' for everything but the quote and '\' itself
	curarg += ch; state = STATE_DOUBLEQUOTED;
	break;
	}
	}
	switch(state) // final state
	{
	case STATE_EATING_SPACES:
	return true;
	case STATE_ARGUMENT:
	args.push_back(curarg);
	return true;
	default: // ERROR to end in one of the other states
	return false;
	}
	}

	void RPCExecutor::request(const QString &command)
	{
	std::vector<std::string> args;
	if(!parseCommandLine(args, command.toStdString()))
	{
	emit reply(RPCConsole::CMD_ERROR, QString("Parse error: unbalanced ' or \""));
	return;
	}
	if(args.empty())
	return; // Nothing to do
	try
	{
	std::string strPrint;
	// Convert argument list to JSON objects in method-dependent way,
	// and pass it along with the method name to the dispatcher.
	json_spirit::Value result = tableRPC.execute(
	args[0],
	RPCConvertValues(args[0], std::vector<std::string>(args.begin() + 1, args.end())));

	// Format result reply
	if (result.type() == json_spirit::null_type)
	strPrint = "";
	else if (result.type() == json_spirit::str_type)
	strPrint = result.get_str();
	else
	strPrint = write_string(result, true);

	emit reply(RPCConsole::CMD_REPLY, QString::fromStdString(strPrint));
	}
	catch (json_spirit::Object& objError)
	{
	try // Nice formatting for standard-format error
	{
	int code = find_value(objError, "code").get_int();
	std::string message = find_value(objError, "message").get_str();
	emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(message) + " (code " + QString::number(code) + ")");
	}
	catch(std::runtime_error &) // raised when converting to invalid type, i.e. missing code or message
	{ // Show raw JSON object
	emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(write_string(json_spirit::Value(objError), false)));
	}
	}
	catch (std::exception& e)
	{
	emit reply(RPCConsole::CMD_ERROR, QString("Error: ") + QString::fromStdString(e.what()));
	}
	}

	RPCConsole::RPCConsole(QWidget *parent) :
	QDialog(parent),
	ui(new Ui::RPCConsole),
	clientModel(0),
	historyPtr(0),
	cachedNodeid(-1)
	{
	ui->setupUi(this);
	GUIUtil::restoreWindowGeometry("nRPCConsoleWindow", this->size(), this);

	#ifndef Q_OS_MAC
	ui->openDebugLogfileButton->setIcon(QIcon(":/icons/export"));
	#endif

	// Install event filter for up and down arrow
	ui->lineEdit->installEventFilter(this);
	ui->messagesWidget->installEventFilter(this);

	connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));
	connect(ui->btnClearTrafficGraph, SIGNAL(clicked()), ui->trafficGraph, SLOT(clear()));

	// set library version labels
	ui->openSSLVersion->setText(SSLeay_version(SSLEAY_VERSION));
	#ifdef ENABLE_WALLET
	ui->berkeleyDBVersion->setText(DbEnv::version(0, 0, 0));
	#else
	ui->label_berkeleyDBVersion->hide();
	ui->berkeleyDBVersion->hide();
	#endif

	startExecutor();
	setTrafficGraphRange(INITIAL_TRAFFIC_GRAPH_MINS);

	ui->detailWidget->hide();
	ui->peerHeading->setText(tr("Select a peer to view detailed information."));

	clear();
	}

	RPCConsole::~RPCConsole()
	{
	GUIUtil::saveWindowGeometry("nRPCConsoleWindow", this);
	emit stopExecutor();
	delete ui;
	}

	bool RPCConsole::eventFilter(QObject* obj, QEvent *event)
	{
	if(event->type() == QEvent::KeyPress) // Special key handling
	{
	QKeyEvent keyevt = static_cast<QKeyEvent>(event);
	int key = keyevt->key();
	Qt::KeyboardModifiers mod = keyevt->modifiers();
	switch(key)
	{
	case Qt::Key_Up: if(obj == ui->lineEdit) { browseHistory(-1); return true; } break;
	case Qt::Key_Down: if(obj == ui->lineEdit) { browseHistory(1); return true; } break;
	case Qt::Key_PageUp: /* pass paging keys to messages widget */
	case Qt::Key_PageDown:
	if(obj == ui->lineEdit)
	{
	QApplication::postEvent(ui->messagesWidget, new QKeyEvent(*keyevt));
	return true;
	}
	break;
	default:
	// Typing in messages widget brings focus to line edit, and redirects key there
	// Exclude most combinations and keys that emit no text, except paste shortcuts
	if(obj == ui->messagesWidget && (
	(!mod && !keyevt->text().isEmpty() && key != Qt::Key_Tab) \|\|
	((mod & Qt::ControlModifier) && key == Qt::Key_V) \|\|
	((mod & Qt::ShiftModifier) && key == Qt::Key_Insert)))
	{
	ui->lineEdit->setFocus();
	QApplication::postEvent(ui->lineEdit, new QKeyEvent(*keyevt));
	return true;
	}
	}
	}
	return QDialog::eventFilter(obj, event);
	}

	void RPCConsole::setClientModel(ClientModel *model)
	{
	clientModel = model;
	ui->trafficGraph->setClientModel(model);
	if(model)
	{
	// Keep up to date with client
	setNumConnections(model->getNumConnections());
	connect(model, SIGNAL(numConnectionsChanged(int)), this, SLOT(setNumConnections(int)));

	setNumBlocks(model->getNumBlocks());
	connect(model, SIGNAL(numBlocksChanged(int)), this, SLOT(setNumBlocks(int)));

	updateTrafficStats(model->getTotalBytesRecv(), model->getTotalBytesSent());
	connect(model, SIGNAL(bytesChanged(quint64,quint64)), this, SLOT(updateTrafficStats(quint64, quint64)));

	// set up peer table
	ui->peerWidget->setModel(model->getPeerTableModel());
	ui->peerWidget->verticalHeader()->hide();
	ui->peerWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
	ui->peerWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
	ui->peerWidget->setSelectionMode(QAbstractItemView::SingleSelection);
	ui->peerWidget->setColumnWidth(PeerTableModel::Address, ADDRESS_COLUMN_WIDTH);
	ui->peerWidget->setColumnWidth(PeerTableModel::Subversion, SUBVERSION_COLUMN_WIDTH);
	ui->peerWidget->setColumnWidth(PeerTableModel::Ping, PING_COLUMN_WIDTH);

	// connect the peerWidget selection model to our peerSelected() handler
	connect(ui->peerWidget->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
	this, SLOT(peerSelected(const QItemSelection &, const QItemSelection &)));
	connect(model->getPeerTableModel(), SIGNAL(layoutChanged()), this, SLOT(peerLayoutChanged()));

	// Provide initial values
	ui->clientVersion->setText(model->formatFullVersion());
	ui->clientName->setText(model->clientName());
	ui->buildDate->setText(model->formatBuildDate());
	ui->startupTime->setText(model->formatClientStartupTime());

	ui->networkName->setText(QString::fromStdString(Params().NetworkIDString()));
	}
	}

	static QString categoryClass(int category)
	{
	switch(category)
	{
	case RPCConsole::CMD_REQUEST: return "cmd-request"; break;
	case RPCConsole::CMD_REPLY: return "cmd-reply"; break;
	case RPCConsole::CMD_ERROR: return "cmd-error"; break;
	default: return "misc";
	}
	}

	void RPCConsole::clear()
	{
	ui->messagesWidget->clear();
	history.clear();
	historyPtr = 0;
	ui->lineEdit->clear();
	ui->lineEdit->setFocus();

	// Add smoothly scaled icon images.
	// (when using width/height on an img, Qt uses nearest instead of linear interpolation)
	for(int i=0; ICON_MAPPING[i].url; ++i)
	{
	ui->messagesWidget->document()->addResource(
	QTextDocument::ImageResource,
	QUrl(ICON_MAPPING[i].url),
	QImage(ICON_MAPPING[i].source).scaled(ICON_SIZE, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
	}

	// Set default style sheet
	ui->messagesWidget->document()->setDefaultStyleSheet(
	"table { }"
	"td.time { color: #808080; padding-top: 3px; } "
	"td.message { font-family: monospace; font-size: 12px; } " // Todo: Remove fixed font-size
	"td.cmd-request { color: #006060; } "
	"td.cmd-error { color: red; } "
	"b { color: #006060; } "
	);

	message(CMD_REPLY, (tr("Welcome to the Bitcoin RPC console.") + "<br>" +
	tr("Use up and down arrows to navigate history, and <b>Ctrl-L</b> to clear screen.") + "<br>" +
	tr("Type <b>help</b> for an overview of available commands.")), true);
	}

	void RPCConsole::reject()
	{
	// Ignore escape keypress if this is not a seperate window
	if(windowType() != Qt::Widget)
	QDialog::reject();
	}

	void RPCConsole::message(int category, const QString &message, bool html)
	{
	QTime time = QTime::currentTime();
	QString timeString = time.toString();
	QString out;
	out += "<table><tr><td class=\"time\" width=\"65\">" + timeString + "</td>";
	out += "<td class=\"icon\" width=\"32\"><img src=\"" + categoryClass(category) + "\"></td>";
	out += "<td class=\"message " + categoryClass(category) + "\" valign=\"middle\">";
	if(html)
	out += message;
	else
	out += GUIUtil::HtmlEscape(message, true);
	out += "</td></tr></table>";
	ui->messagesWidget->append(out);
	}

	void RPCConsole::setNumConnections(int count)
	{
	if (!clientModel)
	return;

	QString connections = QString::number(count) + " (";
	connections += tr("In:") + " " + QString::number(clientModel->getNumConnections(CONNECTIONS_IN)) + " / ";
	connections += tr("Out:") + " " + QString::number(clientModel->getNumConnections(CONNECTIONS_OUT)) + ")";

	ui->numberOfConnections->setText(connections);
	}

	void RPCConsole::setNumBlocks(int count)
	{
	ui->numberOfBlocks->setText(QString::number(count));
	if(clientModel)
	ui->lastBlockTime->setText(clientModel->getLastBlockDate().toString());
	}

	void RPCConsole::on_lineEdit_returnPressed()
	{
	QString cmd = ui->lineEdit->text();
	ui->lineEdit->clear();

	if(!cmd.isEmpty())
	{
	message(CMD_REQUEST, cmd);
	emit cmdRequest(cmd);
	// Remove command, if already in history
	history.removeOne(cmd);
	// Append command to history
	history.append(cmd);
	// Enforce maximum history size
	while(history.size() > CONSOLE_HISTORY)
	history.removeFirst();
	// Set pointer to end of history
	historyPtr = history.size();
	// Scroll console view to end
	scrollToEnd();
	}
	}

	void RPCConsole::browseHistory(int offset)
	{
	historyPtr += offset;
	if(historyPtr < 0)
	historyPtr = 0;
	if(historyPtr > history.size())
	historyPtr = history.size();
	QString cmd;
	if(historyPtr < history.size())
	cmd = history.at(historyPtr);
	ui->lineEdit->setText(cmd);
	}

	void RPCConsole::startExecutor()
	{
	QThread *thread = new QThread;
	RPCExecutor *executor = new RPCExecutor();
	executor->moveToThread(thread);

	// Replies from executor object must go to this object
	connect(executor, SIGNAL(reply(int,QString)), this, SLOT(message(int,QString)));
	// Requests from this object must go to executor
	connect(this, SIGNAL(cmdRequest(QString)), executor, SLOT(request(QString)));

	// On stopExecutor signal
	// - queue executor for deletion (in execution thread)
	// - quit the Qt event loop in the execution thread
	connect(this, SIGNAL(stopExecutor()), executor, SLOT(deleteLater()));
	connect(this, SIGNAL(stopExecutor()), thread, SLOT(quit()));
	// Queue the thread for deletion (in this thread) when it is finished
	connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));

	// Default implementation of QThread::run() simply spins up an event loop in the thread,
	// which is what we want.
	thread->start();
	}

	void RPCConsole::on_tabWidget_currentChanged(int index)
	{
	if(ui->tabWidget->widget(index) == ui->tab_console)
	{
	ui->lineEdit->setFocus();
	}
	}

	void RPCConsole::on_openDebugLogfileButton_clicked()
	{
	GUIUtil::openDebugLogfile();
	}

	void RPCConsole::scrollToEnd()
	{
	QScrollBar *scrollbar = ui->messagesWidget->verticalScrollBar();
	scrollbar->setValue(scrollbar->maximum());
	}

	void RPCConsole::on_sldGraphRange_valueChanged(int value)
	{
	const int multiplier = 5; // each position on the slider represents 5 min
	int mins = value * multiplier;
	setTrafficGraphRange(mins);
	}

	QString RPCConsole::FormatBytes(quint64 bytes)
	{
	if(bytes < 1024)
	return QString(tr("%1 B")).arg(bytes);
	if(bytes < 1024 * 1024)
	return QString(tr("%1 KB")).arg(bytes / 1024);
	if(bytes < 1024 * 1024 * 1024)
	return QString(tr("%1 MB")).arg(bytes / 1024 / 1024);

	return QString(tr("%1 GB")).arg(bytes / 1024 / 1024 / 1024);
	}

	void RPCConsole::setTrafficGraphRange(int mins)
	{
	ui->trafficGraph->setGraphRangeMins(mins);
	ui->lblGraphRange->setText(GUIUtil::formatDurationStr(mins * 60));
	}

	void RPCConsole::updateTrafficStats(quint64 totalBytesIn, quint64 totalBytesOut)
	{
	ui->lblBytesIn->setText(FormatBytes(totalBytesIn));
	ui->lblBytesOut->setText(FormatBytes(totalBytesOut));
	}

	void RPCConsole::peerSelected(const QItemSelection &selected, const QItemSelection &deselected)
	{
	Q_UNUSED(deselected);

	if (!clientModel \|\| selected.indexes().isEmpty())
	return;

	const CNodeCombinedStats *stats = clientModel->getPeerTableModel()->getNodeStats(selected.indexes().first().row());
	if (stats)
	updateNodeDetail(stats);
	}

	void RPCConsole::peerLayoutChanged()
	{
	if (!clientModel)
	return;

	const CNodeCombinedStats *stats = NULL;
	bool fUnselect = false;
	bool fReselect = false;

	if (cachedNodeid == -1) // no node selected yet
	return;

	// find the currently selected row
	int selectedRow;
	QModelIndexList selectedModelIndex = ui->peerWidget->selectionModel()->selectedIndexes();
	if (selectedModelIndex.isEmpty())
	selectedRow = -1;
	else
	selectedRow = selectedModelIndex.first().row();

	// check if our detail node has a row in the table (it may not necessarily
	// be at selectedRow since its position can change after a layout change)
	int detailNodeRow = clientModel->getPeerTableModel()->getRowByNodeId(cachedNodeid);

	if (detailNodeRow < 0)
	{
	// detail node dissapeared from table (node disconnected)
	fUnselect = true;
	cachedNodeid = -1;
	ui->detailWidget->hide();
	ui->peerHeading->setText(tr("Select a peer to view detailed information."));
	}
	else
	{
	if (detailNodeRow != selectedRow)
	{
	// detail node moved position
	fUnselect = true;
	fReselect = true;
	}

	// get fresh stats on the detail node.
	stats = clientModel->getPeerTableModel()->getNodeStats(detailNodeRow);
	}

	if (fUnselect && selectedRow >= 0)
	{
	ui->peerWidget->selectionModel()->select(QItemSelection(selectedModelIndex.first(), selectedModelIndex.last()),
	QItemSelectionModel::Deselect);
	}

	if (fReselect)
	{
	ui->peerWidget->selectRow(detailNodeRow);
	}

	if (stats)
	updateNodeDetail(stats);
	}

	void RPCConsole::updateNodeDetail(const CNodeCombinedStats *stats)
	{
	// Update cached nodeid
	cachedNodeid = stats->nodeStats.nodeid;

	// update the detail ui with latest node information
	QString peerAddrDetails(QString::fromStdString(stats->nodeStats.addrName));
	if (!stats->nodeStats.addrLocal.empty())
	peerAddrDetails += "<br />" + tr("via %1").arg(QString::fromStdString(stats->nodeStats.addrLocal));
	ui->peerHeading->setText(peerAddrDetails);
	ui->peerServices->setText(GUIUtil::formatServicesStr(stats->nodeStats.nServices));
	ui->peerLastSend->setText(stats->nodeStats.nLastSend ? GUIUtil::formatDurationStr(GetTime() - stats->nodeStats.nLastSend) : tr("never"));
	ui->peerLastRecv->setText(stats->nodeStats.nLastRecv ? GUIUtil::formatDurationStr(GetTime() - stats->nodeStats.nLastRecv) : tr("never"));
	ui->peerBytesSent->setText(FormatBytes(stats->nodeStats.nSendBytes));
	ui->peerBytesRecv->setText(FormatBytes(stats->nodeStats.nRecvBytes));
	ui->peerConnTime->setText(GUIUtil::formatDurationStr(GetTime() - stats->nodeStats.nTimeConnected));
	ui->peerPingTime->setText(GUIUtil::formatPingTime(stats->nodeStats.dPingTime));
	ui->peerVersion->setText(QString("%1").arg(stats->nodeStats.nVersion));
	ui->peerSubversion->setText(QString::fromStdString(stats->nodeStats.cleanSubVer));
	ui->peerDirection->setText(stats->nodeStats.fInbound ? tr("Inbound") : tr("Outbound"));
	ui->peerHeight->setText(QString("%1").arg(stats->nodeStats.nStartingHeight));
	ui->peerSyncNode->setText(stats->nodeStats.fSyncNode ? tr("Yes") : tr("No"));

	// This check fails for example if the lock was busy and
	// nodeStateStats couldn't be fetched.
	if (stats->fNodeStateStatsAvailable) {
	// Ban score is init to 0
	ui->peerBanScore->setText(QString("%1").arg(stats->nodeStateStats.nMisbehavior));

	// Sync height is init to -1
	if (stats->nodeStateStats.nSyncHeight > -1)
	ui->peerSyncHeight->setText(QString("%1").arg(stats->nodeStateStats.nSyncHeight));
	else
	ui->peerSyncHeight->setText(tr("Unknown"));
	} else {
	ui->peerBanScore->setText(tr("Fetching..."));
	ui->peerSyncHeight->setText(tr("Fetching..."));
	}

	ui->detailWidget->show();
	}

	void RPCConsole::resizeEvent(QResizeEvent *event)
	{
	QWidget::resizeEvent(event);
	}

	void RPCConsole::showEvent(QShowEvent *event)
	{
	QWidget::showEvent(event);

	if (!clientModel)
	return;

	// start PeerTableModel auto refresh
	clientModel->getPeerTableModel()->startAutoRefresh();
	}

	void RPCConsole::hideEvent(QHideEvent *event)
	{
	QWidget::hideEvent(event);

	if (!clientModel)
	return;

	// stop PeerTableModel auto refresh
	clientModel->getPeerTableModel()->stopAutoRefresh();
	}
	diff --git a/src/qt/rpcconsole.h b/src/qt/rpcconsole.h
	index 64bb5c29b3..1ffff92758 100644
	--- a/src/qt/rpcconsole.h
	+++ b/src/qt/rpcconsole.h
	@@ -1,103 +1,103 @@
	// 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.

	#ifndef RPCCONSOLE_H
	#define RPCCONSOLE_H

	#include "guiutil.h"
	#include "peertablemodel.h"

	#include "net.h"

	#include <QDialog>

	class ClientModel;

	-QT_BEGIN_NAMESPACE
	-class QItemSelection;
	-QT_END_NAMESPACE
	-
	namespace Ui {
	class RPCConsole;
	}

	+QT_BEGIN_NAMESPACE
	+class QItemSelection;
	+QT_END_NAMESPACE
	+
	/** Local Bitcoin RPC console. */
	class RPCConsole: public QDialog
	{
	Q_OBJECT

	public:
	explicit RPCConsole(QWidget *parent);
	~RPCConsole();

	void setClientModel(ClientModel *model);

	enum MessageClass {
	MC_ERROR,
	MC_DEBUG,
	CMD_REQUEST,
	CMD_REPLY,
	CMD_ERROR
	};

	protected:
	virtual bool eventFilter(QObject* obj, QEvent *event);

	private slots:
	void on_lineEdit_returnPressed();
	void on_tabWidget_currentChanged(int index);
	/** open the debug.log from the current datadir */
	void on_openDebugLogfileButton_clicked();
	/** change the time range of the network traffic graph */
	void on_sldGraphRange_valueChanged(int value);
	/** update traffic statistics */
	void updateTrafficStats(quint64 totalBytesIn, quint64 totalBytesOut);
	void resizeEvent(QResizeEvent *event);
	void showEvent(QShowEvent *event);
	void hideEvent(QHideEvent *event);

	public slots:
	void clear();
	void reject();
	void message(int category, const QString &message, bool html = false);
	/** Set number of connections shown in the UI */
	void setNumConnections(int count);
	/** Set number of blocks shown in the UI */
	void setNumBlocks(int count);
	/** Go forward or back in history */
	void browseHistory(int offset);
	/** Scroll console view to end */
	void scrollToEnd();
	/** Handle selection of peer in peers list */
	void peerSelected(const QItemSelection &selected, const QItemSelection &deselected);
	/** Handle updated peer information */
	void peerLayoutChanged();

	signals:
	// For RPC command executor
	void stopExecutor();
	void cmdRequest(const QString &command);

	private:
	static QString FormatBytes(quint64 bytes);
	void startExecutor();
	void setTrafficGraphRange(int mins);
	/** show detailed information on ui about selected node */
	void updateNodeDetail(const CNodeCombinedStats *stats);

	enum ColumnWidths
	{
	ADDRESS_COLUMN_WIDTH = 200,
	SUBVERSION_COLUMN_WIDTH = 100,
	PING_COLUMN_WIDTH = 80
	};

	Ui::RPCConsole *ui;
	ClientModel *clientModel;
	QStringList history;
	int historyPtr;
	NodeId cachedNodeid;
	};

	#endif // RPCCONSOLE_H
	diff --git a/src/qt/sendcoinsdialog.h b/src/qt/sendcoinsdialog.h
	index 6cdf4a00c8..a090fa42d5 100644
	--- a/src/qt/sendcoinsdialog.h
	+++ b/src/qt/sendcoinsdialog.h
	@@ -1,86 +1,86 @@
	// 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 SENDCOINSDIALOG_H
	#define SENDCOINSDIALOG_H

	#include "walletmodel.h"

	#include <QDialog>
	#include <QString>

	class OptionsModel;
	class SendCoinsEntry;
	class SendCoinsRecipient;

	-QT_BEGIN_NAMESPACE
	-class QUrl;
	-QT_END_NAMESPACE
	-
	namespace Ui {
	class SendCoinsDialog;
	}

	+QT_BEGIN_NAMESPACE
	+class QUrl;
	+QT_END_NAMESPACE
	+
	/** Dialog for sending bitcoins */
	class SendCoinsDialog : public QDialog
	{
	Q_OBJECT

	public:
	explicit SendCoinsDialog(QWidget *parent = 0);
	~SendCoinsDialog();

	void setModel(WalletModel *model);

	/** Set up the tab chain manually, as Qt messes up the tab chain by default in some cases (issue https://bugreports.qt-project.org/browse/QTBUG-10907).
	*/
	QWidget setupTabChain(QWidget prev);

	void setAddress(const QString &address);
	void pasteEntry(const SendCoinsRecipient &rv);
	bool handlePaymentRequest(const SendCoinsRecipient &recipient);

	public slots:
	void clear();
	void reject();
	void accept();
	SendCoinsEntry *addEntry();
	void updateTabsAndLabels();
	void setBalance(qint64 balance, qint64 unconfirmedBalance, qint64 immatureBalance,
	qint64 watchOnlyBalance, qint64 watchUnconfBalance, qint64 watchImmatureBalance);

	private:
	Ui::SendCoinsDialog *ui;
	WalletModel *model;
	bool fNewRecipientAllowed;

	// Process WalletModel::SendCoinsReturn and generate a pair consisting
	// of a message and message flags for use in emit message().
	// Additional parameter msgArg can be used via .arg(msgArg).
	void processSendCoinsReturn(const WalletModel::SendCoinsReturn &sendCoinsReturn, const QString &msgArg = QString());

	private slots:
	void on_sendButton_clicked();
	void removeEntry(SendCoinsEntry* entry);
	void updateDisplayUnit();
	void coinControlFeatureChanged(bool);
	void coinControlButtonClicked();
	void coinControlChangeChecked(int);
	void coinControlChangeEdited(const QString &);
	void coinControlUpdateLabels();
	void coinControlClipboardQuantity();
	void coinControlClipboardAmount();
	void coinControlClipboardFee();
	void coinControlClipboardAfterFee();
	void coinControlClipboardBytes();
	void coinControlClipboardPriority();
	void coinControlClipboardLowOutput();
	void coinControlClipboardChange();

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

	#endif // SENDCOINSDIALOG_H
	diff --git a/src/qt/splashscreen.cpp b/src/qt/splashscreen.cpp
	index 5dd110b36a..feb0f3350f 100644
	--- a/src/qt/splashscreen.cpp
	+++ b/src/qt/splashscreen.cpp
	@@ -1,148 +1,149 @@
	// 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 "splashscreen.h"

	-#include "version.h"
	#include "clientversion.h"
	#include "init.h"
	#include "ui_interface.h"
	#include "util.h"
	+#include "version.h"
	+
	#ifdef ENABLE_WALLET
	#include "wallet.h"
	#endif

	#include <QApplication>
	#include <QPainter>

	SplashScreen::SplashScreen(const QPixmap &pixmap, Qt::WindowFlags f, bool isTestNet) :
	QSplashScreen(pixmap, f)
	{
	setAutoFillBackground(true);

	// set reference point, paddings
	int paddingRight = 50;
	int paddingTop = 50;
	int titleVersionVSpace = 17;
	int titleCopyrightVSpace = 40;

	float fontFactor = 1.0;

	// define text to place
	QString titleText = tr("Bitcoin Core");
	QString versionText = QString("Version %1").arg(QString::fromStdString(FormatFullVersion()));
	QString copyrightText = QChar(0xA9)+QString(" 2009-%1 ").arg(COPYRIGHT_YEAR) + QString(tr("The Bitcoin Core developers"));
	QString testnetAddText = QString(tr("[testnet]")); // define text to place as single text object

	QString font = "Arial";

	// load the bitmap for writing some text over it
	QPixmap newPixmap;
	if(isTestNet) {
	newPixmap = QPixmap(":/images/splash_testnet");
	}
	else {
	newPixmap = QPixmap(":/images/splash");
	}

	QPainter pixPaint(&newPixmap);
	pixPaint.setPen(QColor(100,100,100));

	// check font size and drawing with
	pixPaint.setFont(QFont(font, 33*fontFactor));
	QFontMetrics fm = pixPaint.fontMetrics();
	int titleTextWidth = fm.width(titleText);
	if(titleTextWidth > 160) {
	// strange font rendering, Arial probably not found
	fontFactor = 0.75;
	}

	pixPaint.setFont(QFont(font, 33*fontFactor));
	fm = pixPaint.fontMetrics();
	titleTextWidth = fm.width(titleText);
	pixPaint.drawText(newPixmap.width()-titleTextWidth-paddingRight,paddingTop,titleText);

	pixPaint.setFont(QFont(font, 15*fontFactor));

	// if the version string is to long, reduce size
	fm = pixPaint.fontMetrics();
	int versionTextWidth = fm.width(versionText);
	if(versionTextWidth > titleTextWidth+paddingRight-10) {
	pixPaint.setFont(QFont(font, 10*fontFactor));
	titleVersionVSpace -= 5;
	}
	pixPaint.drawText(newPixmap.width()-titleTextWidth-paddingRight+2,paddingTop+titleVersionVSpace,versionText);

	// draw copyright stuff
	pixPaint.setFont(QFont(font, 10*fontFactor));
	pixPaint.drawText(newPixmap.width()-titleTextWidth-paddingRight,paddingTop+titleCopyrightVSpace,copyrightText);

	// draw testnet string if testnet is on
	if(isTestNet) {
	QFont boldFont = QFont(font, 10*fontFactor);
	boldFont.setWeight(QFont::Bold);
	pixPaint.setFont(boldFont);
	fm = pixPaint.fontMetrics();
	int testnetAddTextWidth = fm.width(testnetAddText);
	pixPaint.drawText(newPixmap.width()-testnetAddTextWidth-10,15,testnetAddText);
	}

	pixPaint.end();

	this->setPixmap(newPixmap);

	subscribeToCoreSignals();
	}

	SplashScreen::~SplashScreen()
	{
	unsubscribeFromCoreSignals();
	}

	void SplashScreen::slotFinish(QWidget *mainWin)
	{
	finish(mainWin);
	}

	static void InitMessage(SplashScreen *splash, const std::string &message)
	{
	QMetaObject::invokeMethod(splash, "showMessage",
	Qt::QueuedConnection,
	Q_ARG(QString, QString::fromStdString(message)),
	Q_ARG(int, Qt::AlignBottom\|Qt::AlignHCenter),
	Q_ARG(QColor, QColor(55,55,55)));
	}

	static void ShowProgress(SplashScreen *splash, const std::string &title, int nProgress)
	{
	InitMessage(splash, title + strprintf("%d", nProgress) + "%");
	}

	#ifdef ENABLE_WALLET
	static void ConnectWallet(SplashScreen splash, CWallet wallet)
	{
	wallet->ShowProgress.connect(boost::bind(ShowProgress, splash, _1, _2));
	}
	#endif

	void SplashScreen::subscribeToCoreSignals()
	{
	// Connect signals to client
	uiInterface.InitMessage.connect(boost::bind(InitMessage, this, _1));
	uiInterface.ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
	#ifdef ENABLE_WALLET
	uiInterface.LoadWallet.connect(boost::bind(ConnectWallet, this, _1));
	#endif
	}

	void SplashScreen::unsubscribeFromCoreSignals()
	{
	// Disconnect signals from client
	uiInterface.InitMessage.disconnect(boost::bind(InitMessage, this, _1));
	uiInterface.ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
	#ifdef ENABLE_WALLET
	if(pwalletMain)
	pwalletMain->ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
	#endif
	}
	diff --git a/src/qt/transactiondesc.cpp b/src/qt/transactiondesc.cpp
	index 727b8dc66d..4923718341 100644
	--- a/src/qt/transactiondesc.cpp
	+++ b/src/qt/transactiondesc.cpp
	@@ -1,320 +1,320 @@
	// 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 "paymentserver.h"
	+#include "transactionrecord.h"

	#include "base58.h"
	#include "db.h"
	#include "main.h"
	-#include "paymentserver.h"
	#include "script/script.h"
	-#include "transactionrecord.h"
	#include "timedata.h"
	#include "ui_interface.h"
	#include "util.h"
	#include "wallet.h"

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

	using namespace std;

	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, TransactionRecord rec, 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(ISMINE_ALL);
	int64_t nDebit = wtx.GetDebit(ISMINE_ALL);
	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
	if (CBitcoinAddress(rec->address).IsValid())
	{
	CTxDestination address = CBitcoinAddress(rec->address).Get();
	if (wallet->mapAddressBook.count(address))
	{
	strHTML += "<b>" + tr("From") + ":</b> " + tr("unknown") + "<br>";
	strHTML += "<b>" + tr("To") + ":</b> ";
	strHTML += GUIUtil::HtmlEscape(rec->address);
	QString addressOwned = (::IsMine(*wallet, address) == ISMINE_SPENDABLE) ? tr("own address") : tr("watch-only");
	if (!wallet->mapAddressBook[address].name.empty())
	strHTML += " (" + addressOwned + ", " + tr("label") + ": " + GUIUtil::HtmlEscape(wallet->mapAddressBook[address].name) + ")";
	else
	strHTML += " (" + addressOwned + ")";
	strHTML += "<br>";
	}
	}
	}
	}

	//
	// 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, ISMINE_ALL);
	strHTML += "<b>" + tr("Credit") + ":</b> ";
	if (wtx.IsInMainChain())
	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::formatHtmlWithUnit(unit, nNet) + "<br>";
	}
	else
	{
	isminetype fAllFromMe = ISMINE_SPENDABLE;
	BOOST_FOREACH(const CTxIn& txin, wtx.vin)
	{
	isminetype mine = wallet->IsMine(txin);
	if(fAllFromMe > mine) fAllFromMe = mine;
	}

	isminetype fAllToMe = ISMINE_SPENDABLE;
	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	{
	isminetype mine = wallet->IsMine(txout);
	if(fAllToMe > mine) fAllToMe = mine;
	}

	if (fAllFromMe)
	{
	if(fAllFromMe == ISMINE_WATCH_ONLY)
	strHTML += "<b>" + tr("From") + ":</b> " + tr("watch-only") + "<br>";

	//
	// Debit
	//
	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	{
	// Ignore change
	isminetype toSelf = wallet->IsMine(txout);
	if ((toSelf == ISMINE_SPENDABLE) && (fAllFromMe == ISMINE_SPENDABLE))
	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());
	if(toSelf == ISMINE_SPENDABLE)
	strHTML += " (own address)";
	else if(toSelf == ISMINE_WATCH_ONLY)
	strHTML += " (watch-only)";
	strHTML += "<br>";
	}
	}

	strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -txout.nValue) + "<br>";
	if(toSelf)
	strHTML += "<b>" + tr("Credit") + ":</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("Total debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -nValue) + "<br>";
	strHTML += "<b>" + tr("Total credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, nValue) + "<br>";
	}

	int64_t nTxFee = nDebit - wtx.GetValueOut();
	if (nTxFee > 0)
	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::formatHtmlWithUnit(unit, -wallet->GetDebit(txin, ISMINE_ALL)) + "<br>";
	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	if (wallet->IsMine(txout))
	strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, wallet->GetCredit(txout, ISMINE_ALL)) + "<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(), rec->idx) + "<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::formatHtmlWithUnit(unit, -wallet->GetDebit(txin, ISMINE_ALL)) + "<br>";
	BOOST_FOREACH(const CTxOut& txout, wtx.vout)
	if(wallet->IsMine(txout))
	strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, wallet->GetCredit(txout, ISMINE_ALL)) + "<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::formatHtmlWithUnit(unit, vout.nValue);
	strHTML = strHTML + " IsMine=" + (wallet->IsMine(vout) & ISMINE_SPENDABLE ? tr("true") : tr("false")) + "</li>";
	strHTML = strHTML + " IsWatchOnly=" + (wallet->IsMine(vout) & ISMINE_WATCH_ONLY ? tr("true") : tr("false")) + "</li>";
	}
	}
	}

	strHTML += "</ul>";
	}

	strHTML += "</font></html>";
	return strHTML;
	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 09:50 (1 d, 6 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187254
Default Alt Text: (146 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions