No OneTemporary
Actions

Size

55 KB

Subscribers

None

View Options

	diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
	index e15bc6690..c143411c7 100644
	--- a/src/qt/bitcoingui.cpp
	+++ b/src/qt/bitcoingui.cpp
	@@ -1,870 +1,881 @@
	/*
	* Qt4 bitcoin GUI.
	*
	* W.J. van der Laan 2011-2012
	* The Bitcoin Developers 2011-2012
	*/
	#include "bitcoingui.h"
	#include "transactiontablemodel.h"
	#include "addressbookpage.h"
	#include "sendcoinsdialog.h"
	#include "messagepage.h"
	#include "verifymessagedialog.h"
	#include "optionsdialog.h"
	#include "aboutdialog.h"
	#include "clientmodel.h"
	#include "walletmodel.h"
	#include "editaddressdialog.h"
	#include "optionsmodel.h"
	#include "transactiondescdialog.h"
	#include "addresstablemodel.h"
	#include "transactionview.h"
	#include "overviewpage.h"
	#include "bitcoinunits.h"
	#include "guiconstants.h"
	#include "askpassphrasedialog.h"
	#include "notificator.h"
	#include "guiutil.h"
	#include "rpcconsole.h"

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

	#include <QApplication>
	#include <QMainWindow>
	#include <QMenuBar>
	#include <QMenu>
	#include <QIcon>
	#include <QTabWidget>
	#include <QVBoxLayout>
	#include <QToolBar>
	#include <QStatusBar>
	#include <QLabel>
	#include <QLineEdit>
	#include <QPushButton>
	#include <QLocale>
	#include <QMessageBox>
	#include <QProgressBar>
	#include <QStackedWidget>
	#include <QDateTime>
	#include <QMovie>
	#include <QFileDialog>
	#include <QDesktopServices>
	#include <QTimer>

	#include <QDragEnterEvent>
	#include <QUrl>

	#include <iostream>

	BitcoinGUI::BitcoinGUI(QWidget *parent):
	QMainWindow(parent),
	clientModel(0),
	walletModel(0),
	encryptWalletAction(0),
	changePassphraseAction(0),
	aboutQtAction(0),
	trayIcon(0),
	notificator(0),
	rpcConsole(0)
	{
	resize(850, 550);
	setWindowTitle(tr("Bitcoin Wallet"));
	#ifndef Q_WS_MAC
	qApp->setWindowIcon(QIcon(":icons/bitcoin"));
	setWindowIcon(QIcon(":icons/bitcoin"));
	#else
	setUnifiedTitleAndToolBarOnMac(true);
	QApplication::setAttribute(Qt::AA_DontShowIconsInMenus);
	#endif
	// Accept D&D of URIs
	setAcceptDrops(true);

	// Create actions for the toolbar, menu bar and tray/dock icon
	createActions();

	// Create application menu bar
	createMenuBar();

	// Create the toolbars
	createToolBars();

	// Create the tray icon (or setup the dock icon)
	createTrayIcon();

	// Create tabs
	overviewPage = new OverviewPage();

	transactionsPage = new QWidget(this);
	QVBoxLayout *vbox = new QVBoxLayout();
	transactionView = new TransactionView(this);
	vbox->addWidget(transactionView);
	transactionsPage->setLayout(vbox);

	addressBookPage = new AddressBookPage(AddressBookPage::ForEditing, AddressBookPage::SendingTab);

	receiveCoinsPage = new AddressBookPage(AddressBookPage::ForEditing, AddressBookPage::ReceivingTab);

	sendCoinsPage = new SendCoinsDialog(this);

	messagePage = new MessagePage(this);

	centralWidget = new QStackedWidget(this);
	centralWidget->addWidget(overviewPage);
	centralWidget->addWidget(transactionsPage);
	centralWidget->addWidget(addressBookPage);
	centralWidget->addWidget(receiveCoinsPage);
	centralWidget->addWidget(sendCoinsPage);
	#ifdef FIRST_CLASS_MESSAGING
	centralWidget->addWidget(messagePage);
	#endif
	setCentralWidget(centralWidget);

	// Create status bar
	statusBar();

	// Status bar notification icons
	QFrame *frameBlocks = new QFrame();
	frameBlocks->setContentsMargins(0,0,0,0);
	frameBlocks->setMinimumWidth(56);
	frameBlocks->setMaximumWidth(56);
	QHBoxLayout *frameBlocksLayout = new QHBoxLayout(frameBlocks);
	frameBlocksLayout->setContentsMargins(3,0,3,0);
	frameBlocksLayout->setSpacing(3);
	labelEncryptionIcon = new QLabel();
	labelConnectionsIcon = new QLabel();
	labelBlocksIcon = new QLabel();
	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);

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

	syncIconMovie = new QMovie(":/movies/update_spinner", "mng", this);

	// Clicking on a transaction on the overview page simply sends you to transaction history page
	connect(overviewPage, SIGNAL(transactionClicked(QModelIndex)), this, SLOT(gotoHistoryPage()));
	connect(overviewPage, SIGNAL(transactionClicked(QModelIndex)), transactionView, SLOT(focusTransaction(QModelIndex)));

	// Doubleclicking on a transaction on the transaction history page shows details
	connect(transactionView, SIGNAL(doubleClicked(QModelIndex)), transactionView, SLOT(showDetails()));

	rpcConsole = new RPCConsole(this);
	connect(openRPCConsoleAction, SIGNAL(triggered()), rpcConsole, SLOT(show()));

	gotoOverviewPage();
	}

	BitcoinGUI::~BitcoinGUI()
	{
	if(trayIcon) // Hide tray icon, as deleting will let it linger until quit (on Ubuntu)
	trayIcon->hide();
	#ifdef Q_WS_MAC
	delete appMenuBar;
	#endif
	}

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

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

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

	addressBookAction = new QAction(QIcon(":/icons/address-book"), tr("&Address Book"), this);
	addressBookAction->setToolTip(tr("Edit the list of stored addresses and labels"));
	addressBookAction->setCheckable(true);
	addressBookAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_5));
	tabGroup->addAction(addressBookAction);

	receiveCoinsAction = new QAction(QIcon(":/icons/receiving_addresses"), tr("&Receive coins"), this);
	receiveCoinsAction->setToolTip(tr("Show the list of addresses for receiving payments"));
	receiveCoinsAction->setCheckable(true);
	receiveCoinsAction->setShortcut(QKeySequence(Qt::ALT + Qt::Key_3));
	tabGroup->addAction(receiveCoinsAction);

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

	messageAction = new QAction(QIcon(":/icons/edit"), tr("Sign &message..."), this);
	messageAction->setToolTip(tr("Prove you control an address"));
	#ifdef FIRST_CLASS_MESSAGING
	messageAction->setCheckable(true);
	#endif
	tabGroup->addAction(messageAction);

	connect(overviewAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
	connect(overviewAction, SIGNAL(triggered()), this, SLOT(gotoOverviewPage()));
	connect(historyAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
	connect(historyAction, SIGNAL(triggered()), this, SLOT(gotoHistoryPage()));
	connect(addressBookAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
	connect(addressBookAction, SIGNAL(triggered()), this, SLOT(gotoAddressBookPage()));
	connect(receiveCoinsAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
	connect(receiveCoinsAction, SIGNAL(triggered()), this, SLOT(gotoReceiveCoinsPage()));
	connect(sendCoinsAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
	connect(sendCoinsAction, SIGNAL(triggered()), this, SLOT(gotoSendCoinsPage()));
	connect(messageAction, SIGNAL(triggered()), this, SLOT(showNormalIfMinimized()));
	connect(messageAction, SIGNAL(triggered()), this, SLOT(gotoMessagePage()));

	quitAction = new QAction(QIcon(":/icons/quit"), tr("E&xit"), this);
	quitAction->setToolTip(tr("Quit application"));
	quitAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q));
	quitAction->setMenuRole(QAction::QuitRole);
	aboutAction = new QAction(QIcon(":/icons/bitcoin"), tr("&About %1").arg(qApp->applicationName()), this);
	aboutAction->setToolTip(tr("Show information about Bitcoin"));
	aboutAction->setMenuRole(QAction::AboutRole);
	aboutQtAction = new QAction(tr("About &Qt"), this);
	aboutQtAction->setToolTip(tr("Show information about Qt"));
	aboutQtAction->setMenuRole(QAction::AboutQtRole);
	optionsAction = new QAction(QIcon(":/icons/options"), tr("&Options..."), this);
	optionsAction->setToolTip(tr("Modify configuration options for Bitcoin"));
	optionsAction->setMenuRole(QAction::PreferencesRole);
	toggleHideAction = new QAction(QIcon(":/icons/bitcoin"), tr("Show/Hide &Bitcoin"), this);
	toggleHideAction->setToolTip(tr("Show or hide the Bitcoin window"));
	exportAction = new QAction(QIcon(":/icons/export"), tr("&Export..."), this);
	exportAction->setToolTip(tr("Export the data in the current tab to a file"));
	encryptWalletAction = new QAction(QIcon(":/icons/lock_closed"), tr("&Encrypt Wallet..."), this);
	encryptWalletAction->setToolTip(tr("Encrypt or decrypt wallet"));
	encryptWalletAction->setCheckable(true);
	backupWalletAction = new QAction(QIcon(":/icons/filesave"), tr("&Backup Wallet..."), this);
	backupWalletAction->setToolTip(tr("Backup wallet to another location"));
	changePassphraseAction = new QAction(QIcon(":/icons/key"), tr("&Change Passphrase..."), this);
	changePassphraseAction->setToolTip(tr("Change the passphrase used for wallet encryption"));
	openRPCConsoleAction = new QAction(QIcon(":/icons/debugwindow"), tr("&Debug window"), this);
	openRPCConsoleAction->setToolTip(tr("Open debugging and diagnostic console"));
	verifyMessageAction = new QAction(QIcon(":/icons/transaction_0"), tr("&Verify message..."), this);
	verifyMessageAction->setToolTip(tr("Verify a message signature"));

	connect(quitAction, SIGNAL(triggered()), qApp, SLOT(quit()));
	connect(optionsAction, SIGNAL(triggered()), this, SLOT(optionsClicked()));
	connect(aboutAction, SIGNAL(triggered()), this, SLOT(aboutClicked()));
	connect(aboutQtAction, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
	connect(toggleHideAction, SIGNAL(triggered()), this, SLOT(toggleHidden()));
	connect(encryptWalletAction, SIGNAL(triggered(bool)), this, SLOT(encryptWallet(bool)));
	connect(backupWalletAction, SIGNAL(triggered()), this, SLOT(backupWallet()));
	connect(changePassphraseAction, SIGNAL(triggered()), this, SLOT(changePassphrase()));
	connect(verifyMessageAction, SIGNAL(triggered()), this, SLOT(verifyMessage()));
	}

	void BitcoinGUI::createMenuBar()
	{
	#ifdef Q_WS_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"));
	file->addAction(backupWalletAction);
	file->addAction(exportAction);
	#ifndef FIRST_CLASS_MESSAGING
	file->addAction(messageAction);
	#endif
	file->addAction(verifyMessageAction);
	file->addSeparator();
	file->addAction(quitAction);

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

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

	void BitcoinGUI::createToolBars()
	{
	QToolBar *toolbar = addToolBar(tr("Tabs toolbar"));
	toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
	toolbar->addAction(overviewAction);
	toolbar->addAction(sendCoinsAction);
	toolbar->addAction(receiveCoinsAction);
	toolbar->addAction(historyAction);
	toolbar->addAction(addressBookAction);
	#ifdef FIRST_CLASS_MESSAGING
	toolbar->addAction(messageAction);
	#endif

	QToolBar *toolbar2 = addToolBar(tr("Actions toolbar"));
	toolbar2->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
	toolbar2->addAction(exportAction);
	}

	void BitcoinGUI::setClientModel(ClientModel *clientModel)
	{
	this->clientModel = clientModel;
	if(clientModel)
	{
	if(clientModel->isTestNet())
	{
	setWindowTitle(windowTitle() + QString(" ") + tr("[testnet]"));
	#ifndef Q_WS_MAC
	qApp->setWindowIcon(QIcon(":icons/bitcoin_testnet"));
	setWindowIcon(QIcon(":icons/bitcoin_testnet"));
	#else
	MacDockIconHandler::instance()->setIcon(QIcon(":icons/bitcoin_testnet"));
	#endif
	if(trayIcon)
	{
	trayIcon->setToolTip(tr("Bitcoin client") + QString(" ") + tr("[testnet]"));
	trayIcon->setIcon(QIcon(":/icons/toolbar_testnet"));
	toggleHideAction->setIcon(QIcon(":/icons/toolbar_testnet"));
	}
	}

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

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

	// Report errors from network/worker thread
	connect(clientModel, SIGNAL(error(QString,QString,bool)), this, SLOT(error(QString,QString,bool)));

	rpcConsole->setClientModel(clientModel);
	}
	}

	void BitcoinGUI::setWalletModel(WalletModel *walletModel)
	{
	this->walletModel = walletModel;
	if(walletModel)
	{
	// Report errors from wallet thread
	connect(walletModel, SIGNAL(error(QString,QString,bool)), this, SLOT(error(QString,QString,bool)));

	// Put transaction list in tabs
	transactionView->setModel(walletModel);

	overviewPage->setModel(walletModel);
	addressBookPage->setModel(walletModel->getAddressTableModel());
	receiveCoinsPage->setModel(walletModel->getAddressTableModel());
	sendCoinsPage->setModel(walletModel);
	messagePage->setModel(walletModel);

	setEncryptionStatus(walletModel->getEncryptionStatus());
	connect(walletModel, SIGNAL(encryptionStatusChanged(int)), this, SLOT(setEncryptionStatus(int)));

	// Balloon popup for new transaction
	connect(walletModel->getTransactionTableModel(), SIGNAL(rowsInserted(QModelIndex,int,int)),
	this, SLOT(incomingTransaction(QModelIndex,int,int)));

	// Ask for passphrase if needed
	connect(walletModel, SIGNAL(requireUnlock()), this, SLOT(unlockWallet()));
	}
	}

	void BitcoinGUI::createTrayIcon()
	{
	QMenu *trayIconMenu;
	#ifndef Q_WS_MAC
	trayIcon = new QSystemTrayIcon(this);
	trayIconMenu = new QMenu(this);
	trayIcon->setContextMenu(trayIconMenu);
	trayIcon->setToolTip(tr("Bitcoin client"));
	trayIcon->setIcon(QIcon(":/icons/toolbar"));
	connect(trayIcon, SIGNAL(activated(QSystemTrayIcon::ActivationReason)),
	this, SLOT(trayIconActivated(QSystemTrayIcon::ActivationReason)));
	trayIcon->show();
	#else
	// Note: On Mac, the dock icon is used to provide the tray's functionality.
	MacDockIconHandler *dockIconHandler = MacDockIconHandler::instance();
	trayIconMenu = dockIconHandler->dockMenu();
	#endif

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

	notificator = new Notificator(qApp->applicationName(), trayIcon);
	}

	#ifndef Q_WS_MAC
	void BitcoinGUI::trayIconActivated(QSystemTrayIcon::ActivationReason reason)
	{
	if(reason == QSystemTrayIcon::Trigger)
	{
	// Click on system tray icon triggers "show/hide Bitcoin"
	toggleHideAction->trigger();
	}
	}
	#endif

	void BitcoinGUI::optionsClicked()
	{
	if(!clientModel \|\| !clientModel->getOptionsModel())
	return;
	OptionsDialog dlg;
	dlg.setModel(clientModel->getOptionsModel());
	dlg.exec();
	}

	void BitcoinGUI::aboutClicked()
	{
	AboutDialog dlg;
	dlg.setModel(clientModel);
	dlg.exec();
	}

	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, int nTotalBlocks)
	{
	// don't show / hide progressBar and it's label if we have no connection(s) to the network
	if (!clientModel \|\| clientModel->getNumConnections() == 0)
	{
	progressBarLabel->setVisible(false);
	progressBar->setVisible(false);

	return;
	}

	QString tooltip;

	if(count < nTotalBlocks)
	{
	int nRemainingBlocks = nTotalBlocks - count;
	float nPercentageDone = count / (nTotalBlocks * 0.01f);

	if (clientModel->getStatusBarWarnings() == "")
	{
	progressBarLabel->setText(tr("Synchronizing with network..."));
	progressBarLabel->setVisible(true);
	progressBar->setFormat(tr("~%n block(s) remaining", "", nRemainingBlocks));
	progressBar->setMaximum(nTotalBlocks);
	progressBar->setValue(count);
	progressBar->setVisible(true);
	}
	else
	{
	progressBarLabel->setText(clientModel->getStatusBarWarnings());
	progressBarLabel->setVisible(true);
	progressBar->setVisible(false);
	}
	tooltip = tr("Downloaded %1 of %2 blocks of transaction history (%3% done).").arg(count).arg(nTotalBlocks).arg(nPercentageDone, 0, 'f', 2);
	}
	else
	{
	if (clientModel->getStatusBarWarnings() == "")
	progressBarLabel->setVisible(false);
	else
	{
	progressBarLabel->setText(clientModel->getStatusBarWarnings());
	progressBarLabel->setVisible(true);
	}
	progressBar->setVisible(false);
	tooltip = tr("Downloaded %1 blocks of transaction history.").arg(count);
	}

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

	// Represent time from last generated block in human readable text
	if(secs <= 0)
	{
	// Fully up to date. Leave text empty.
	}
	else if(secs < 60)
	{
	text = tr("%n second(s) ago","",secs);
	}
	else if(secs < 60*60)
	{
	text = tr("%n minute(s) ago","",secs/60);
	}
	else if(secs < 246060)
	{
	text = tr("%n hour(s) ago","",secs/(60*60));
	}
	else
	{
	text = tr("%n day(s) ago","",secs/(606024));
	}

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

	overviewPage->showOutOfSyncWarning(false);
	}
	else
	{
	tooltip = tr("Catching up...") + QString("<br>") + tooltip;
	labelBlocksIcon->setMovie(syncIconMovie);
	syncIconMovie->start();

	overviewPage->showOutOfSyncWarning(true);
	}

	if(!text.isEmpty())
	{
	tooltip += QString("<br>");
	tooltip += tr("Last received block was generated %1.").arg(text);
	}

	// 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::error(const QString &title, const QString &message, bool modal)
	{
	// Report errors from network/worker thread
	if(modal)
	{
	QMessageBox::critical(this, title, message, QMessageBox::Ok, QMessageBox::Ok);
	} else {
	notificator->notify(Notificator::Critical, title, message);
	}
	}

	void BitcoinGUI::changeEvent(QEvent *e)
	{
	QMainWindow::changeEvent(e);
	#ifndef Q_WS_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_WS_MAC // Ignored on Mac
	if(!clientModel->getOptionsModel()->getMinimizeToTray() &&
	!clientModel->getOptionsModel()->getMinimizeOnClose())
	{
	qApp->quit();
	}
	#endif
	}
	QMainWindow::closeEvent(event);
	}

	void BitcoinGUI::askFee(qint64 nFeeRequired, bool *payFee)
	{
	QString strMessage =
	tr("This transaction is over the size limit. You can still send it for a fee of %1, "
	"which goes to the nodes that process your transaction and helps to support the network. "
	"Do you want to pay the fee?").arg(
	BitcoinUnits::formatWithUnit(BitcoinUnits::BTC, nFeeRequired));
	QMessageBox::StandardButton retval = QMessageBox::question(
	this, tr("Confirm transaction fee"), strMessage,
	QMessageBox::Yes\|QMessageBox::Cancel, QMessageBox::Yes);
	*payFee = (retval == QMessageBox::Yes);
	}

	void BitcoinGUI::incomingTransaction(const QModelIndex & parent, int start, int end)
	{
	if(!walletModel \|\| !clientModel)
	return;
	TransactionTableModel *ttm = walletModel->getTransactionTableModel();
	qint64 amount = ttm->index(start, TransactionTableModel::Amount, parent)
	.data(Qt::EditRole).toULongLong();
	if(!clientModel->inInitialBlockDownload())
	{
	// On new transaction, make an info balloon
	// Unless the initial block download is in progress, to prevent balloon-spam
	QString date = ttm->index(start, TransactionTableModel::Date, parent)
	.data().toString();
	QString type = ttm->index(start, TransactionTableModel::Type, parent)
	.data().toString();
	QString address = ttm->index(start, TransactionTableModel::ToAddress, parent)
	.data().toString();
	QIcon icon = qvariant_cast<QIcon>(ttm->index(start,
	TransactionTableModel::ToAddress, parent)
	.data(Qt::DecorationRole));

	notificator->notify(Notificator::Information,
	(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(walletModel->getOptionsModel()->getDisplayUnit(), amount, true))
	.arg(type)
	.arg(address), icon);
	}
	}

	void BitcoinGUI::gotoOverviewPage()
	{
	overviewAction->setChecked(true);
	centralWidget->setCurrentWidget(overviewPage);

	exportAction->setEnabled(false);
	disconnect(exportAction, SIGNAL(triggered()), 0, 0);
	}

	void BitcoinGUI::gotoHistoryPage()
	{
	historyAction->setChecked(true);
	centralWidget->setCurrentWidget(transactionsPage);

	exportAction->setEnabled(true);
	disconnect(exportAction, SIGNAL(triggered()), 0, 0);
	connect(exportAction, SIGNAL(triggered()), transactionView, SLOT(exportClicked()));
	}

	void BitcoinGUI::gotoAddressBookPage()
	{
	addressBookAction->setChecked(true);
	centralWidget->setCurrentWidget(addressBookPage);

	exportAction->setEnabled(true);
	disconnect(exportAction, SIGNAL(triggered()), 0, 0);
	connect(exportAction, SIGNAL(triggered()), addressBookPage, SLOT(exportClicked()));
	}

	void BitcoinGUI::gotoReceiveCoinsPage()
	{
	receiveCoinsAction->setChecked(true);
	centralWidget->setCurrentWidget(receiveCoinsPage);

	exportAction->setEnabled(true);
	disconnect(exportAction, SIGNAL(triggered()), 0, 0);
	connect(exportAction, SIGNAL(triggered()), receiveCoinsPage, SLOT(exportClicked()));
	}

	void BitcoinGUI::gotoSendCoinsPage()
	{
	sendCoinsAction->setChecked(true);
	centralWidget->setCurrentWidget(sendCoinsPage);

	exportAction->setEnabled(false);
	disconnect(exportAction, SIGNAL(triggered()), 0, 0);
	}

	void BitcoinGUI::gotoMessagePage(QString addr)
	{
	if(!addr.isEmpty())
	messagePage->setAddress(addr);

	#ifdef FIRST_CLASS_MESSAGING
	messageAction->setChecked(true);
	centralWidget->setCurrentWidget(messagePage);

	exportAction->setEnabled(false);
	disconnect(exportAction, SIGNAL(triggered()), 0, 0);
	#else
	messagePage->show();
	#endif
	}

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

	void BitcoinGUI::dropEvent(QDropEvent *event)
	{
	if(event->mimeData()->hasUrls())
	{
	- gotoSendCoinsPage();
	+ int nValidUrisFound = 0;
	QList<QUrl> uris = event->mimeData()->urls();
	foreach(const QUrl &uri, uris)
	{
	- sendCoinsPage->handleURI(uri.toString());
	+ if (sendCoinsPage->handleURI(uri.toString()))
	+ nValidUrisFound++;
	}
	+
	+ // if valid URIs were found
	+ if (nValidUrisFound)
	+ gotoSendCoinsPage();
	+ else
	+ notificator->notify(Notificator::Warning, tr("URI handling"), tr("URI can not be parsed! This can be caused by an invalid Bitcoin address or malformed URI parameters."));
	}

	event->acceptProposedAction();
	}

	void BitcoinGUI::handleURI(QString strURI)
	{
	- gotoSendCoinsPage();
	- sendCoinsPage->handleURI(strURI);
	-
	- showNormalIfMinimized();
	+ // URI has to be valid
	+ if (sendCoinsPage->handleURI(strURI))
	+ {
	+ showNormalIfMinimized();
	+ gotoSendCoinsPage();
	+ }
	+ else
	+ notificator->notify(Notificator::Warning, tr("URI handling"), tr("URI can not be parsed! This can be caused by an invalid Bitcoin address or malformed URI parameters."));
	}

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

	void BitcoinGUI::encryptWallet(bool status)
	{
	if(!walletModel)
	return;
	AskPassphraseDialog dlg(status ? AskPassphraseDialog::Encrypt:
	AskPassphraseDialog::Decrypt, this);
	dlg.setModel(walletModel);
	dlg.exec();

	setEncryptionStatus(walletModel->getEncryptionStatus());
	}

	void BitcoinGUI::backupWallet()
	{
	QString saveDir = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
	QString filename = QFileDialog::getSaveFileName(this, tr("Backup Wallet"), saveDir, tr("Wallet Data (*.dat)"));
	if(!filename.isEmpty()) {
	if(!walletModel->backupWallet(filename)) {
	QMessageBox::warning(this, tr("Backup Failed"), tr("There was an error trying to save the wallet data to the new location."));
	}
	}
	}

	void BitcoinGUI::changePassphrase()
	{
	AskPassphraseDialog dlg(AskPassphraseDialog::ChangePass, this);
	dlg.setModel(walletModel);
	dlg.exec();
	}

	void BitcoinGUI::verifyMessage()
	{
	VerifyMessageDialog *dlg = new VerifyMessageDialog(this);
	dlg->setAttribute(Qt::WA_DeleteOnClose);
	dlg->show();
	}

	void BitcoinGUI::unlockWallet()
	{
	if(!walletModel)
	return;
	// Unlock wallet when requested by wallet model
	if(walletModel->getEncryptionStatus() == WalletModel::Locked)
	{
	AskPassphraseDialog dlg(AskPassphraseDialog::Unlock, this);
	dlg.setModel(walletModel);
	dlg.exec();
	}
	}

	void BitcoinGUI::showNormalIfMinimized(bool fToggleHidden)
	{
	// 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);
	}
	diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
	index 5dedc90d6..a8c232885 100644
	--- a/src/qt/guiutil.cpp
	+++ b/src/qt/guiutil.cpp
	@@ -1,452 +1,457 @@
	#include "guiutil.h"
	#include "bitcoinaddressvalidator.h"
	#include "walletmodel.h"
	#include "bitcoinunits.h"
	#include "util.h"
	#include "init.h"
	+#include "base58.h"

	#include <QString>
	#include <QDateTime>
	#include <QDoubleValidator>
	#include <QFont>
	#include <QLineEdit>
	#include <QUrl>
	#include <QTextDocument> // For Qt::escape
	#include <QAbstractItemView>
	#include <QApplication>
	#include <QClipboard>
	#include <QFileDialog>
	#include <QDesktopServices>
	#include <QThread>

	#include <boost/filesystem.hpp>
	#include <boost/filesystem/fstream.hpp>

	#ifdef WIN32
	#ifdef _WIN32_WINNT
	#undef _WIN32_WINNT
	#endif
	#define _WIN32_WINNT 0x0501
	#ifdef _WIN32_IE
	#undef _WIN32_IE
	#endif
	#define _WIN32_IE 0x0501
	#define WIN32_LEAN_AND_MEAN 1
	#ifndef NOMINMAX
	#define NOMINMAX
	#endif
	#include "shlwapi.h"
	#include "shlobj.h"
	#include "shellapi.h"
	#endif

	namespace GUIUtil {

	QString dateTimeStr(const QDateTime &date)
	{
	return date.date().toString(Qt::SystemLocaleShortDate) + QString(" ") + date.toString("hh:mm");
	}

	QString dateTimeStr(qint64 nTime)
	{
	return dateTimeStr(QDateTime::fromTime_t((qint32)nTime));
	}

	QFont bitcoinAddressFont()
	{
	QFont font("Monospace");
	font.setStyleHint(QFont::TypeWriter);
	return font;
	}

	void setupAddressWidget(QLineEdit widget, QWidget parent)
	{
	widget->setMaxLength(BitcoinAddressValidator::MaxAddressLength);
	widget->setValidator(new BitcoinAddressValidator(parent));
	widget->setFont(bitcoinAddressFont());
	}

	void setupAmountWidget(QLineEdit widget, QWidget parent)
	{
	QDoubleValidator *amountValidator = new QDoubleValidator(parent);
	amountValidator->setDecimals(8);
	amountValidator->setBottom(0.0);
	widget->setValidator(amountValidator);
	widget->setAlignment(Qt::AlignRight\|Qt::AlignVCenter);
	}

	bool parseBitcoinURI(const QUrl &uri, SendCoinsRecipient *out)
	{
	if(uri.scheme() != QString("bitcoin"))
	return false;

	+ // check if the address is valid
	+ CBitcoinAddress addressFromUri(uri.path().toStdString());
	+ if (!addressFromUri.IsValid())
	+ return false;
	+
	SendCoinsRecipient rv;
	rv.address = uri.path();
	rv.amount = 0;
	QList<QPair<QString, QString> > items = uri.queryItems();
	for (QList<QPair<QString, QString> >::iterator i = items.begin(); i != items.end(); i++)
	{
	bool fShouldReturnFalse = false;
	if (i->first.startsWith("req-"))
	{
	i->first.remove(0, 4);
	fShouldReturnFalse = true;
	}

	if (i->first == "label")
	{
	rv.label = i->second;
	fShouldReturnFalse = false;
	}
	else if (i->first == "amount")
	{
	if(!i->second.isEmpty())
	{
	if(!BitcoinUnits::parse(BitcoinUnits::BTC, i->second, &rv.amount))
	{
	return false;
	}
	}
	fShouldReturnFalse = false;
	}

	if (fShouldReturnFalse)
	return false;
	}
	if(out)
	{
	*out = rv;
	}
	return true;
	}

	bool parseBitcoinURI(QString uri, SendCoinsRecipient *out)
	{
	// Convert bitcoin:// to bitcoin:
	//
	// Cannot handle this later, because bitcoin:// will cause Qt to see the part after // as host,
	// which will lowercase it (and thus invalidate the address).
	if(uri.startsWith("bitcoin://"))
	{
	uri.replace(0, 10, "bitcoin:");
	}
	QUrl uriInstance(uri);
	return parseBitcoinURI(uriInstance, out);
	}

	QString HtmlEscape(const QString& str, bool fMultiLine)
	{
	QString escaped = Qt::escape(str);
	if(fMultiLine)
	{
	escaped = escaped.replace("\n", "<br>\n");
	}
	return escaped;
	}

	QString HtmlEscape(const std::string& str, bool fMultiLine)
	{
	return HtmlEscape(QString::fromStdString(str), fMultiLine);
	}

	void copyEntryData(QAbstractItemView *view, int column, int role)
	{
	if(!view \|\| !view->selectionModel())
	return;
	QModelIndexList selection = view->selectionModel()->selectedRows(column);

	if(!selection.isEmpty())
	{
	// Copy first item
	QApplication::clipboard()->setText(selection.at(0).data(role).toString());
	}
	}

	QString getSaveFileName(QWidget *parent, const QString &caption,
	const QString &dir,
	const QString &filter,
	QString *selectedSuffixOut)
	{
	QString selectedFilter;
	QString myDir;
	if(dir.isEmpty()) // Default to user documents location
	{
	myDir = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
	}
	else
	{
	myDir = dir;
	}
	QString result = QFileDialog::getSaveFileName(parent, caption, myDir, filter, &selectedFilter);

	/* Extract first suffix from filter pattern "Description (.foo)" or "Description (.foo .bar ...) /
	QRegExp filter_re(".* \\(\\\\.(.)[ \\)]");
	QString selectedSuffix;
	if(filter_re.exactMatch(selectedFilter))
	{
	selectedSuffix = filter_re.cap(1);
	}

	/* Add suffix if needed */
	QFileInfo info(result);
	if(!result.isEmpty())
	{
	if(info.suffix().isEmpty() && !selectedSuffix.isEmpty())
	{
	/* No suffix specified, add selected suffix */
	if(!result.endsWith("."))
	result.append(".");
	result.append(selectedSuffix);
	}
	}

	/* Return selected suffix if asked to */
	if(selectedSuffixOut)
	{
	*selectedSuffixOut = selectedSuffix;
	}
	return result;
	}

	Qt::ConnectionType blockingGUIThreadConnection()
	{
	if(QThread::currentThread() != QCoreApplication::instance()->thread())
	{
	return Qt::BlockingQueuedConnection;
	}
	else
	{
	return Qt::DirectConnection;
	}
	}

	bool checkPoint(const QPoint &p, const QWidget *w)
	{
	- QWidget *atW = qApp->widgetAt(w->mapToGlobal(p));
	- if(!atW) return false;
	- return atW->topLevelWidget() == w;
	+ QWidget *atW = qApp->widgetAt(w->mapToGlobal(p));
	+ if (!atW) return false;
	+ return atW->topLevelWidget() == w;
	}

	bool isObscured(QWidget *w)
	{
	-
	- return !(checkPoint(QPoint(0, 0), w)
	- && checkPoint(QPoint(w->width() - 1, 0), w)
	- && checkPoint(QPoint(0, w->height() - 1), w)
	- && checkPoint(QPoint(w->width() - 1, w->height() - 1), w)
	- && checkPoint(QPoint(w->width()/2, w->height()/2), w));
	+ return !(checkPoint(QPoint(0, 0), w)
	+ && checkPoint(QPoint(w->width() - 1, 0), w)
	+ && checkPoint(QPoint(0, w->height() - 1), w)
	+ && checkPoint(QPoint(w->width() - 1, w->height() - 1), w)
	+ && checkPoint(QPoint(w->width() / 2, w->height() / 2), w));
	}

	void openDebugLogfile()
	{
	boost::filesystem::path pathDebug = GetDataDir() / "debug.log";

	/* Open debug.log with the associated application */
	if (boost::filesystem::exists(pathDebug))
	QDesktopServices::openUrl(QUrl::fromLocalFile(QString::fromStdString(pathDebug.string())));
	}

	ToolTipToRichTextFilter::ToolTipToRichTextFilter(int size_threshold, QObject *parent) :
	QObject(parent), size_threshold(size_threshold)
	{

	}

	bool ToolTipToRichTextFilter::eventFilter(QObject obj, QEvent evt)
	{
	if(evt->type() == QEvent::ToolTipChange)
	{
	QWidget widget = static_cast<QWidget>(obj);
	QString tooltip = widget->toolTip();
	if(tooltip.size() > size_threshold && !tooltip.startsWith("<qt/>") && !Qt::mightBeRichText(tooltip))
	{
	// Prefix <qt/> to make sure Qt detects this as rich text
	// Escape the current message as HTML and replace \n by <br>
	tooltip = "<qt/>" + HtmlEscape(tooltip, true);
	widget->setToolTip(tooltip);
	return true;
	}
	}
	return QObject::eventFilter(obj, evt);
	}

	#ifdef WIN32
	boost::filesystem::path static StartupShortcutPath()
	{
	return GetSpecialFolderPath(CSIDL_STARTUP) / "Bitcoin.lnk";
	}

	bool GetStartOnSystemStartup()
	{
	// check for Bitcoin.lnk
	return boost::filesystem::exists(StartupShortcutPath());
	}

	bool SetStartOnSystemStartup(bool fAutoStart)
	{
	// If the shortcut exists already, remove it for updating
	boost::filesystem::remove(StartupShortcutPath());

	if (fAutoStart)
	{
	CoInitialize(NULL);

	// Get a pointer to the IShellLink interface.
	IShellLink* psl = NULL;
	HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL,
	CLSCTX_INPROC_SERVER, IID_IShellLink,
	reinterpret_cast<void**>(&psl));

	if (SUCCEEDED(hres))
	{
	// Get the current executable path
	TCHAR pszExePath[MAX_PATH];
	GetModuleFileName(NULL, pszExePath, sizeof(pszExePath));

	TCHAR pszArgs[5] = TEXT("-min");

	// Set the path to the shortcut target
	psl->SetPath(pszExePath);
	PathRemoveFileSpec(pszExePath);
	psl->SetWorkingDirectory(pszExePath);
	psl->SetShowCmd(SW_SHOWMINNOACTIVE);
	psl->SetArguments(pszArgs);

	// Query IShellLink for the IPersistFile interface for
	// saving the shortcut in persistent storage.
	IPersistFile* ppf = NULL;
	hres = psl->QueryInterface(IID_IPersistFile,
	reinterpret_cast<void**>(&ppf));
	if (SUCCEEDED(hres))
	{
	WCHAR pwsz[MAX_PATH];
	// Ensure that the string is ANSI.
	MultiByteToWideChar(CP_ACP, 0, StartupShortcutPath().string().c_str(), -1, pwsz, MAX_PATH);
	// Save the link by calling IPersistFile::Save.
	hres = ppf->Save(pwsz, TRUE);
	ppf->Release();
	psl->Release();
	CoUninitialize();
	return true;
	}
	psl->Release();
	}
	CoUninitialize();
	return false;
	}
	return true;
	}

	#elif defined(LINUX)

	// Follow the Desktop Application Autostart Spec:
	// http://standards.freedesktop.org/autostart-spec/autostart-spec-latest.html

	boost::filesystem::path static GetAutostartDir()
	{
	namespace fs = boost::filesystem;

	char* pszConfigHome = getenv("XDG_CONFIG_HOME");
	if (pszConfigHome) return fs::path(pszConfigHome) / "autostart";
	char* pszHome = getenv("HOME");
	if (pszHome) return fs::path(pszHome) / ".config" / "autostart";
	return fs::path();
	}

	boost::filesystem::path static GetAutostartFilePath()
	{
	return GetAutostartDir() / "bitcoin.desktop";
	}

	bool GetStartOnSystemStartup()
	{
	boost::filesystem::ifstream optionFile(GetAutostartFilePath());
	if (!optionFile.good())
	return false;
	// Scan through file for "Hidden=true":
	std::string line;
	while (!optionFile.eof())
	{
	getline(optionFile, line);
	if (line.find("Hidden") != std::string::npos &&
	line.find("true") != std::string::npos)
	return false;
	}
	optionFile.close();

	return true;
	}

	bool SetStartOnSystemStartup(bool fAutoStart)
	{
	if (!fAutoStart)
	boost::filesystem::remove(GetAutostartFilePath());
	else
	{
	char pszExePath[MAX_PATH+1];
	memset(pszExePath, 0, sizeof(pszExePath));
	if (readlink("/proc/self/exe", pszExePath, sizeof(pszExePath)-1) == -1)
	return false;

	boost::filesystem::create_directories(GetAutostartDir());

	boost::filesystem::ofstream optionFile(GetAutostartFilePath(), std::ios_base::out\|std::ios_base::trunc);
	if (!optionFile.good())
	return false;
	// Write a bitcoin.desktop file to the autostart directory:
	optionFile << "[Desktop Entry]\n";
	optionFile << "Type=Application\n";
	optionFile << "Name=Bitcoin\n";
	optionFile << "Exec=" << pszExePath << " -min\n";
	optionFile << "Terminal=false\n";
	optionFile << "Hidden=false\n";
	optionFile.close();
	}
	return true;
	}
	#else

	// TODO: OSX startup stuff; see:
	// http://developer.apple.com/mac/library/documentation/MacOSX/Conceptual/BPSystemStartup/Articles/CustomLogin.html

	bool GetStartOnSystemStartup() { return false; }
	bool SetStartOnSystemStartup(bool fAutoStart) { return false; }

	#endif

	HelpMessageBox::HelpMessageBox(QWidget *parent) :
	QMessageBox(parent)
	{
	header = tr("Bitcoin-Qt") + " " + tr("version") + " " +
	QString::fromStdString(FormatFullVersion()) + "\n\n" +
	tr("Usage:") + "\n" +
	" bitcoin-qt [" + tr("command-line options") + "] " + "\n";

	coreOptions = QString::fromStdString(HelpMessage());

	uiOptions = tr("UI options") + ":\n" +
	" -lang=<lang> " + tr("Set language, for example \"de_DE\" (default: system locale)") + "\n" +
	" -min " + tr("Start minimized") + "\n" +
	" -splash " + tr("Show splash screen on startup (default: 1)") + "\n";

	setWindowTitle(tr("Bitcoin-Qt"));
	setTextFormat(Qt::PlainText);
	// setMinimumWidth is ignored for QMessageBox so put in nonbreaking spaces to make it wider.
	setText(header + QString(QChar(0x2003)).repeated(50));
	setDetailedText(coreOptions + "\n" + uiOptions);
	}

	void HelpMessageBox::exec()
	{
	#if defined(WIN32)
	// On windows, show a message box, as there is no stderr in windowed applications
	QMessageBox::exec();
	#else
	// On other operating systems, the expected action is to print the message to the console.
	QString strUsage = header + "\n" + coreOptions + "\n" + uiOptions;
	fprintf(stderr, "%s", strUsage.toStdString().c_str());
	#endif
	}

	} // namespace GUIUtil

	diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
	index 2eb228d1d..76952e44e 100644
	--- a/src/qt/sendcoinsdialog.cpp
	+++ b/src/qt/sendcoinsdialog.cpp
	@@ -1,289 +1,291 @@
	#include "sendcoinsdialog.h"
	#include "ui_sendcoinsdialog.h"
	#include "walletmodel.h"
	#include "bitcoinunits.h"
	#include "addressbookpage.h"
	#include "optionsmodel.h"
	#include "sendcoinsentry.h"
	#include "guiutil.h"
	#include "askpassphrasedialog.h"

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

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

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

	addEntry();

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

	fNewRecipientAllowed = true;
	}

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

	for(int i = 0; i < ui->entries->count(); ++i)
	{
	SendCoinsEntry entry = qobject_cast<SendCoinsEntry>(ui->entries->itemAt(i)->widget());
	if(entry)
	{
	entry->setModel(model);
	}
	}
	if(model)
	{
	setBalance(model->getBalance(), model->getUnconfirmedBalance(), model->getImmatureBalance());
	connect(model, SIGNAL(balanceChanged(qint64, qint64, qint64)), this, SLOT(setBalance(qint64, qint64, qint64)));
	}
	}

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

	void SendCoinsDialog::on_sendButton_clicked()
	{
	QList<SendCoinsRecipient> recipients;
	bool valid = true;

	if(!model)
	return;

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

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

	// Format confirmation message
	QStringList formatted;
	foreach(const SendCoinsRecipient &rcp, recipients)
	{
	formatted.append(tr("<b>%1</b> to %2 (%3)").arg(BitcoinUnits::formatWithUnit(BitcoinUnits::BTC, rcp.amount), Qt::escape(rcp.label), rcp.address));
	}

	fNewRecipientAllowed = false;

	QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm send coins"),
	tr("Are you sure you want to send %1?").arg(formatted.join(tr(" and "))),
	QMessageBox::Yes\|QMessageBox::Cancel,
	QMessageBox::Cancel);

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

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

	WalletModel::SendCoinsReturn sendstatus = model->sendCoins(recipients);
	switch(sendstatus.status)
	{
	case WalletModel::InvalidAddress:
	QMessageBox::warning(this, tr("Send Coins"),
	tr("The recepient address is not valid, please recheck."),
	QMessageBox::Ok, QMessageBox::Ok);
	break;
	case WalletModel::InvalidAmount:
	QMessageBox::warning(this, tr("Send Coins"),
	tr("The amount to pay must be larger than 0."),
	QMessageBox::Ok, QMessageBox::Ok);
	break;
	case WalletModel::AmountExceedsBalance:
	QMessageBox::warning(this, tr("Send Coins"),
	tr("The amount exceeds your balance."),
	QMessageBox::Ok, QMessageBox::Ok);
	break;
	case WalletModel::AmountWithFeeExceedsBalance:
	QMessageBox::warning(this, tr("Send Coins"),
	tr("The total exceeds your balance when the %1 transaction fee is included.").
	arg(BitcoinUnits::formatWithUnit(BitcoinUnits::BTC, sendstatus.fee)),
	QMessageBox::Ok, QMessageBox::Ok);
	break;
	case WalletModel::DuplicateAddress:
	QMessageBox::warning(this, tr("Send Coins"),
	tr("Duplicate address found, can only send to each address once per send operation."),
	QMessageBox::Ok, QMessageBox::Ok);
	break;
	case WalletModel::TransactionCreationFailed:
	QMessageBox::warning(this, tr("Send Coins"),
	tr("Error: Transaction creation failed."),
	QMessageBox::Ok, QMessageBox::Ok);
	break;
	case WalletModel::TransactionCommitFailed:
	QMessageBox::warning(this, tr("Send Coins"),
	tr("Error: The transaction was rejected. This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here."),
	QMessageBox::Ok, QMessageBox::Ok);
	break;
	case WalletModel::Aborted: // User aborted, nothing to do
	break;
	case WalletModel::OK:
	accept();
	break;
	}
	fNewRecipientAllowed = true;
	}

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

	updateRemoveEnabled();

	ui->sendButton->setDefault(true);
	}

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

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

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

	updateRemoveEnabled();

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

	void SendCoinsDialog::updateRemoveEnabled()
	{
	// Remove buttons are enabled as soon as there is more than one send-entry
	bool enabled = (ui->entries->count() > 1);
	for(int i = 0; i < ui->entries->count(); ++i)
	{
	SendCoinsEntry entry = qobject_cast<SendCoinsEntry>(ui->entries->itemAt(i)->widget());
	if(entry)
	{
	entry->setRemoveEnabled(enabled);
	}
	}
	setupTabChain(0);
	}

	void SendCoinsDialog::removeEntry(SendCoinsEntry* entry)
	{
	delete entry;
	updateRemoveEnabled();
	}

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

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

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

	entry->setValue(rv);
	}

	-
	-void SendCoinsDialog::handleURI(const QString &uri)
	+bool SendCoinsDialog::handleURI(const QString &uri)
	{
	SendCoinsRecipient rv;
	- if(!GUIUtil::parseBitcoinURI(uri, &rv))
	+ // URI has to be valid
	+ if (GUIUtil::parseBitcoinURI(uri, &rv))
	{
	- return;
	+ pasteEntry(rv);
	+ return true;
	}
	- pasteEntry(rv);
	+
	+ return false;
	}

	void SendCoinsDialog::setBalance(qint64 balance, qint64 unconfirmedBalance, qint64 immatureBalance)
	{
	Q_UNUSED(unconfirmedBalance);
	Q_UNUSED(immatureBalance);
	if(!model \|\| !model->getOptionsModel())
	return;

	int unit = model->getOptionsModel()->getDisplayUnit();
	ui->labelBalance->setText(BitcoinUnits::formatWithUnit(unit, balance));
	}
	diff --git a/src/qt/sendcoinsdialog.h b/src/qt/sendcoinsdialog.h
	index 358c8cf85..915b7ad46 100644
	--- a/src/qt/sendcoinsdialog.h
	+++ b/src/qt/sendcoinsdialog.h
	@@ -1,54 +1,54 @@
	#ifndef SENDCOINSDIALOG_H
	#define SENDCOINSDIALOG_H

	#include <QDialog>

	namespace Ui {
	class SendCoinsDialog;
	}
	class WalletModel;
	class SendCoinsEntry;
	class SendCoinsRecipient;

	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 http://bugreports.qt.nokia.com/browse/QTBUG-10907).
	*/
	QWidget setupTabChain(QWidget prev);

	void pasteEntry(const SendCoinsRecipient &rv);
	- void handleURI(const QString &uri);
	+ bool handleURI(const QString &uri);

	public slots:
	void clear();
	void reject();
	void accept();
	SendCoinsEntry *addEntry();
	void updateRemoveEnabled();
	void setBalance(qint64 balance, qint64 unconfirmedBalance, qint64 immatureBalance);

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

	private slots:
	void on_sendButton_clicked();

	void removeEntry(SendCoinsEntry* entry);
	};

	#endif // SENDCOINSDIALOG_H

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 11:31 (1 d, 8 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187625
Default Alt Text: (55 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions