No OneTemporary
Actions

Size

51 KB

Subscribers

None

View Options

	diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
	index 26e823705..eadda586a 100644
	--- a/src/qt/bitcoingui.cpp
	+++ b/src/qt/bitcoingui.cpp
	@@ -1,820 +1,828 @@
	/*
	* Qt4 bitcoin GUI.
	*
	* W.J. van der Laan 2011-2012
	* The Bitcoin Developers 2011-2012
	*/

	#include "bitcoingui.h"

	#include "transactiontablemodel.h"
	#include "optionsdialog.h"
	#include "aboutdialog.h"
	#include "clientmodel.h"
	#include "walletmodel.h"
	#include "walletframe.h"
	#include "optionsmodel.h"
	#include "transactiondescdialog.h"
	#include "bitcoinunits.h"
	#include "guiconstants.h"
	#include "notificator.h"
	#include "guiutil.h"
	#include "rpcconsole.h"
	#include "ui_interface.h"
	#include "wallet.h"
	#include "init.h"

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

	#include <QApplication>
	#include <QMenuBar>
	#include <QMenu>
	#include <QIcon>
	#include <QVBoxLayout>
	#include <QToolBar>
	#include <QStatusBar>
	#include <QLabel>
	#include <QMessageBox>
	#include <QProgressBar>
	#include <QStackedWidget>
	#include <QDateTime>
	#include <QMovie>
	#include <QTimer>
	#include <QDragEnterEvent>
	#if QT_VERSION < 0x050000
	#include <QUrl>
	#include <QTextDocument>
	#endif
	#include <QMimeData>
	#include <QStyle>
	#include <QListWidget>

	#include <iostream>

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

	BitcoinGUI::BitcoinGUI(bool fIsTestnet, QWidget *parent) :
	QMainWindow(parent),
	clientModel(0),
	encryptWalletAction(0),
	changePassphraseAction(0),
	aboutQtAction(0),
	trayIcon(0),
	notificator(0),
	rpcConsole(0),
	prevBlocks(0)
	{
	GUIUtil::restoreWindowGeometry("nWindow", QSize(850, 550), this);

	#ifndef Q_OS_MAC
	if (!fIsTestnet)
	{
	setWindowTitle(tr("Bitcoin") + " - " + tr("Wallet"));
	QApplication::setWindowIcon(QIcon(":icons/bitcoin"));
	setWindowIcon(QIcon(":icons/bitcoin"));
	}
	else
	{
	setWindowTitle(tr("Bitcoin") + " - " + tr("Wallet") + " " + tr("[testnet]"));
	QApplication::setWindowIcon(QIcon(":icons/bitcoin_testnet"));
	setWindowIcon(QIcon(":icons/bitcoin_testnet"));
	}
	#else
	setUnifiedTitleAndToolBarOnMac(true);
	QApplication::setAttribute(Qt::AA_DontShowIconsInMenus);

	if (!fIsTestnet)
	MacDockIconHandler::instance()->setIcon(QIcon(":icons/bitcoin"));
	else
	MacDockIconHandler::instance()->setIcon(QIcon(":icons/bitcoin_testnet"));
	#endif

	// Create wallet frame and make it the central widget
	walletFrame = new WalletFrame(this);
	setCentralWidget(walletFrame);

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

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

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

	rpcConsole = new RPCConsole(this);
	connect(openRPCConsoleAction, SIGNAL(triggered()), rpcConsole, SLOT(show()));
	// prevents an oben 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);
	}

	BitcoinGUI::~BitcoinGUI()
	{
	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);

	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"), this);
	else
	aboutAction = new QAction(QIcon(":/icons/bitcoin_testnet"), tr("&About Bitcoin"), this);
	aboutAction->setStatusTip(tr("Show information about Bitcoin"));
	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("&Used sending addresses..."), this);
	usedSendingAddressesAction->setStatusTip(tr("Edit the list of used sending addresses and labels"));
	usedReceivingAddressesAction = new QAction(QIcon(":/icons/address-book"), tr("Used &receiving addresses..."), this);
	usedReceivingAddressesAction->setStatusTip(tr("Edit the list of used receiving addresses and labels"));

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

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

	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(), clientModel->getNumBlocksOfPeers());
	connect(clientModel, SIGNAL(numBlocksChanged(int,int)), this, SLOT(setNumBlocks(int,int)));

	// Receive and report messages from network/worker thread
	connect(clientModel, SIGNAL(message(QString,QString,unsigned int)), this, SLOT(message(QString,QString,unsigned int)));

	rpcConsole->setClientModel(clientModel);
	walletFrame->setClientModel(clientModel);
	}
	}

	bool BitcoinGUI::addWallet(const QString& name, WalletModel *walletModel)
	{
	return walletFrame->addWallet(name, walletModel);
	}

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

	void BitcoinGUI::removeAllWallets()
	{
	walletFrame->removeAllWallets();
	}

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

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

	trayIcon->show();
	#endif

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

	void BitcoinGUI::createTrayIconMenu()
	{
	QMenu *trayIconMenu;
	#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
	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::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);
	}

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

	if(count < nTotalBlocks)
	{
	tooltip = tr("Processed %1 of %2 (estimated) blocks of transaction history.").arg(count).arg(nTotalBlocks);
	}
	else
	{
	tooltip = tr("Processed %1 blocks of transaction history.").arg(count);
	}

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

	walletFrame->showOutOfSyncWarning(false);

	progressBarLabel->setVisible(false);
	progressBar->setVisible(false);
	}
	else
	{
	// Represent time from last generated block in human readable text
	QString timeBehindText;
	if(secs < 486060)
	{
	timeBehindText = tr("%n hour(s)","",secs/(60*60));
	}
	else if(secs < 142460*60)
	{
	timeBehindText = tr("%n day(s)","",secs/(246060));
	}
	else
	{
	timeBehindText = tr("%n week(s)","",secs/(72460*60));
	}

	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;
	labelBlocksIcon->setMovie(syncIconMovie);
	if(count != prevBlocks)
	syncIconMovie->jumpToNextFrame();
	prevBlocks = count;

	walletFrame->showOutOfSyncWarning(true);

	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;

	// Ensure we get users attention
	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);
	}

	void BitcoinGUI::askFee(qint64 nFeeRequired, bool *payFee)
	{
	if (!clientModel \|\| !clientModel->getOptionsModel())
	return;

	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(clientModel->getOptionsModel()->getDisplayUnit(), 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 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);
	}

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

	void BitcoinGUI::dropEvent(QDropEvent *event)
	{
	if(event->mimeData()->hasUrls())
	{
	int nValidUrisFound = 0;
	QList<QUrl> uris = event->mimeData()->urls();
	foreach(const QUrl &uri, uris)
	{
	SendCoinsRecipient r;
	if (GUIUtil::parseBitcoinURI(uri, &r) && walletFrame->handlePaymentRequest(r))
	nValidUrisFound++;
	}

	// if valid URIs were found
	if (nValidUrisFound)
	walletFrame->gotoSendCoinsPage();
	else
	message(tr("URI handling"), tr("URI can not be parsed! This can be caused by an invalid Bitcoin address or malformed URI parameters."),
	CClientUIInterface::ICON_WARNING);
	}

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

	-void BitcoinGUI::handlePaymentRequest(const SendCoinsRecipient& recipient)
	+bool BitcoinGUI::handlePaymentRequest(const SendCoinsRecipient& recipient)
	{
	- walletFrame->handlePaymentRequest(recipient);
	+ // URI has to be valid
	+ if (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;
	}
	}

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

	void BitcoinGUI::detectShutdown()
	{
	if (ShutdownRequested())
	QMetaObject::invokeMethod(QCoreApplication::instance(), "quit", Qt::QueuedConnection);
	}
	diff --git a/src/qt/bitcoingui.h b/src/qt/bitcoingui.h
	index a5a3ce83b..0394e2f84 100644
	--- a/src/qt/bitcoingui.h
	+++ b/src/qt/bitcoingui.h
	@@ -1,187 +1,187 @@
	#ifndef BITCOINGUI_H
	#define BITCOINGUI_H

	#include <QMainWindow>
	#include <QSystemTrayIcon>
	#include <QMap>

	class TransactionTableModel;
	class WalletFrame;
	class WalletView;
	class ClientModel;
	class WalletModel;
	class WalletStack;
	class TransactionView;
	class OverviewPage;
	class SendCoinsDialog;
	class SendCoinsRecipient;
	class SignVerifyMessageDialog;
	class Notificator;
	class RPCConsole;

	class CWallet;

	QT_BEGIN_NAMESPACE
	class QLabel;
	class QModelIndex;
	class QProgressBar;
	class QStackedWidget;
	class QUrl;
	class QListWidget;
	class QPushButton;
	class QAction;
	QT_END_NAMESPACE

	/**
	Bitcoin GUI main class. This class represents the main window of the Bitcoin UI. It communicates with both the client and
	wallet models to give the user an up-to-date view of the current core state.
	*/
	class BitcoinGUI : public QMainWindow
	{
	Q_OBJECT

	public:
	static const QString DEFAULT_WALLET;

	explicit BitcoinGUI(bool fIsTestnet = false, QWidget *parent = 0);
	~BitcoinGUI();

	/** Set the client model.
	The client model represents the part of the core that communicates with the P2P network, and is wallet-agnostic.
	*/
	void setClientModel(ClientModel *clientModel);
	/** Set the wallet model.
	The wallet model represents a bitcoin wallet, and offers access to the list of transactions, address book and sending
	functionality.
	*/

	bool addWallet(const QString& name, WalletModel *walletModel);
	bool setCurrentWallet(const QString& name);

	void removeAllWallets();

	protected:
	void changeEvent(QEvent *e);
	void closeEvent(QCloseEvent *event);
	void dragEnterEvent(QDragEnterEvent *event);
	void dropEvent(QDropEvent *event);
	bool eventFilter(QObject object, QEvent event);

	private:
	ClientModel *clientModel;
	WalletFrame *walletFrame;

	QLabel *labelEncryptionIcon;
	QLabel *labelConnectionsIcon;
	QLabel *labelBlocksIcon;
	QLabel *progressBarLabel;
	QProgressBar *progressBar;

	QMenuBar *appMenuBar;
	QAction *overviewAction;
	QAction *historyAction;
	QAction *quitAction;
	QAction *sendCoinsAction;
	QAction *usedSendingAddressesAction;
	QAction *usedReceivingAddressesAction;
	QAction *signMessageAction;
	QAction *verifyMessageAction;
	QAction *aboutAction;
	QAction *receiveCoinsAction;
	QAction *optionsAction;
	QAction *toggleHideAction;
	QAction *encryptWalletAction;
	QAction *backupWalletAction;
	QAction *changePassphraseAction;
	QAction *aboutQtAction;
	QAction *openRPCConsoleAction;

	QSystemTrayIcon *trayIcon;
	Notificator *notificator;
	TransactionView *transactionView;
	RPCConsole *rpcConsole;

	QMovie *syncIconMovie;
	/** Keep track of previous number of blocks, to detect progress */
	int prevBlocks;

	/** Create the main UI actions. */
	void createActions(bool fIsTestnet);
	/** Create the menu bar and sub-menus. */
	void createMenuBar();
	/** Create the toolbars */
	void createToolBars();
	/** Create system tray icon and notification */
	void createTrayIcon(bool fIsTestnet);
	/** Create system tray menu (or setup the dock menu) */
	void createTrayIconMenu();

	public slots:
	/** Set number of connections shown in the UI */
	void setNumConnections(int count);
	/** Set number of blocks shown in the UI */
	void setNumBlocks(int count, int nTotalBlocks);
	/** Set the encryption status as shown in the UI.
	@param[in] status current encryption status
	@see WalletModel::EncryptionStatus
	*/
	void setEncryptionStatus(int status);

	/** Notify the user of an event from the core network or transaction handling code.
	@param[in] title the message box / notification title
	@param[in] message the displayed text
	@param[in] style modality and style definitions (icon and used buttons - buttons only for message boxes)
	@see CClientUIInterface::MessageBoxFlags
	@param[in] ret pointer to a bool that will be modified to whether Ok was clicked (modal only)
	*/
	void message(const QString &title, const QString &message, unsigned int style, bool *ret = NULL);

	/** Asks the user whether to pay the transaction fee or to cancel the transaction.
	It is currently not possible to pass a return value to another thread through
	BlockingQueuedConnection, so an indirected pointer is used.
	https://bugreports.qt-project.org/browse/QTBUG-10440

	@param[in] nFeeRequired the required fee
	@param[out] payFee true to pay the fee, false to not pay the fee
	*/
	void askFee(qint64 nFeeRequired, bool *payFee);

	- void handlePaymentRequest(const SendCoinsRecipient& recipient);
	+ bool handlePaymentRequest(const SendCoinsRecipient& recipient);

	/** Show incoming transaction notification for new transactions. */
	void incomingTransaction(const QString& date, int unit, qint64 amount, const QString& type, const QString& address);

	private slots:
	/** Switch to overview (home) page */
	void gotoOverviewPage();
	/** Switch to history (transactions) page */
	void gotoHistoryPage();
	/** Switch to receive coins page */
	void gotoReceiveCoinsPage();
	/** Switch to send coins page */
	void gotoSendCoinsPage(QString addr = "");

	/** Show Sign/Verify Message dialog and switch to sign message tab */
	void gotoSignMessageTab(QString addr = "");
	/** Show Sign/Verify Message dialog and switch to verify message tab */
	void gotoVerifyMessageTab(QString addr = "");

	/** Show configuration dialog */
	void optionsClicked();
	/** Show about dialog */
	void aboutClicked();
	#ifndef Q_OS_MAC
	/** Handle tray icon clicked */
	void trayIconActivated(QSystemTrayIcon::ActivationReason reason);
	#endif

	/** Show window if hidden, unminimize when minimized, rise when obscured or show if hidden and fToggleHidden is true */
	void showNormalIfMinimized(bool fToggleHidden = false);
	/** Simply calls showNormalIfMinimized(true) for use in SLOT() macro */
	void toggleHidden();

	/ called by a timer to check if fRequestShutdown has been set /
	void detectShutdown();
	};

	#endif // BITCOINGUI_H
	diff --git a/src/qt/sendcoinsdialog.h b/src/qt/sendcoinsdialog.h
	index f4bffedc9..b295b7d83 100644
	--- a/src/qt/sendcoinsdialog.h
	+++ b/src/qt/sendcoinsdialog.h
	@@ -1,57 +1,61 @@
	#ifndef SENDCOINSDIALOG_H
	#define SENDCOINSDIALOG_H

	#include <QDialog>
	#include <QVariant>

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

	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 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);
	void updateDisplayUnit();
	+
	+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/walletview.cpp b/src/qt/walletview.cpp
	index 578874c54..57e64b082 100644
	--- a/src/qt/walletview.cpp
	+++ b/src/qt/walletview.cpp
	@@ -1,277 +1,275 @@
	/*
	* Qt4 bitcoin GUI.
	*
	* W.J. van der Laan 2011-2012
	* The Bitcoin Developers 2011-2013
	*/
	#include "walletview.h"
	#include "bitcoingui.h"
	#include "transactiontablemodel.h"
	#include "addressbookpage.h"
	#include "sendcoinsdialog.h"
	#include "receivecoinsdialog.h"
	#include "signverifymessagedialog.h"
	#include "clientmodel.h"
	#include "walletmodel.h"
	#include "optionsmodel.h"
	#include "transactionview.h"
	#include "overviewpage.h"
	#include "askpassphrasedialog.h"
	#include "ui_interface.h"

	#include <QHBoxLayout>
	#include <QVBoxLayout>
	#include <QAction>
	#if QT_VERSION < 0x050000
	#include <QDesktopServices>
	#else
	#include <QStandardPaths>
	#endif
	#include <QFileDialog>
	#include <QPushButton>

	WalletView::WalletView(QWidget *parent):
	QStackedWidget(parent),
	gui(0),
	clientModel(0),
	walletModel(0)
	{
	// Create tabs
	overviewPage = new OverviewPage();

	transactionsPage = new QWidget(this);
	QVBoxLayout *vbox = new QVBoxLayout();
	QHBoxLayout *hbox_buttons = new QHBoxLayout();
	transactionView = new TransactionView(this);
	vbox->addWidget(transactionView);
	QPushButton *exportButton = new QPushButton(tr("&Export"), this);
	exportButton->setToolTip(tr("Export the data in the current tab to a file"));
	#ifndef Q_OS_MAC // Icons on push buttons are very uncommon on Mac
	exportButton->setIcon(QIcon(":/icons/export"));
	#endif
	hbox_buttons->addStretch();
	hbox_buttons->addWidget(exportButton);
	vbox->addLayout(hbox_buttons);
	transactionsPage->setLayout(vbox);

	receiveCoinsPage = new ReceiveCoinsDialog();
	sendCoinsPage = new SendCoinsDialog();

	addWidget(overviewPage);
	addWidget(transactionsPage);
	addWidget(receiveCoinsPage);
	addWidget(sendCoinsPage);

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

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

	// Clicking on "Export" allows to export the transaction list
	connect(exportButton, SIGNAL(clicked()), transactionView, SLOT(exportClicked()));
	}

	WalletView::~WalletView()
	{
	}

	void WalletView::setBitcoinGUI(BitcoinGUI *gui)
	{
	this->gui = gui;
	- if(gui)
	+
	+ if (gui)
	{
	+ // Clicking on a transaction on the overview page sends you to the transactions tab
	connect(overviewPage, SIGNAL(transactionClicked(QModelIndex)), gui, SLOT(gotoHistoryPage()));
	+
	+ // Receive and report messages
	+ connect(this, SIGNAL(message(QString,QString,unsigned int)), gui, SLOT(message(QString,QString,unsigned int)));
	+ connect(sendCoinsPage, SIGNAL(message(QString,QString,unsigned int)), gui, SLOT(message(QString,QString,unsigned int)));
	}
	}

	void WalletView::setClientModel(ClientModel *clientModel)
	{
	this->clientModel = clientModel;
	if (clientModel)
	{
	overviewPage->setClientModel(clientModel);
	}
	}

	void WalletView::setWalletModel(WalletModel *walletModel)
	{
	this->walletModel = walletModel;
	if (walletModel && gui)
	{
	// Receive and report messages from wallet thread
	connect(walletModel, SIGNAL(message(QString,QString,unsigned int)), gui, SLOT(message(QString,QString,unsigned int)));

	// Put transaction list in tabs
	transactionView->setModel(walletModel);
	overviewPage->setWalletModel(walletModel);
	receiveCoinsPage->setModel(walletModel);
	sendCoinsPage->setModel(walletModel);

	setEncryptionStatus();
	connect(walletModel, SIGNAL(encryptionStatusChanged(int)), gui, SLOT(setEncryptionStatus(int)));

	// Balloon pop-up 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 WalletView::incomingTransaction(const QModelIndex& parent, int start, int /end/)
	{
	// Prevent balloon-spam when initial block download is in progress
	if (!walletModel \|\| !clientModel \|\| clientModel->inInitialBlockDownload())
	return;

	TransactionTableModel *ttm = walletModel->getTransactionTableModel();

	QString date = ttm->index(start, TransactionTableModel::Date, parent).data().toString();
	qint64 amount = ttm->index(start, TransactionTableModel::Amount, parent).data(Qt::EditRole).toULongLong();
	QString type = ttm->index(start, TransactionTableModel::Type, parent).data().toString();
	QString address = ttm->index(start, TransactionTableModel::ToAddress, parent).data().toString();

	gui->incomingTransaction(date, walletModel->getOptionsModel()->getDisplayUnit(), amount, type, address);
	}

	void WalletView::gotoOverviewPage()
	{
	setCurrentWidget(overviewPage);
	}

	void WalletView::gotoHistoryPage()
	{
	setCurrentWidget(transactionsPage);
	}

	void WalletView::gotoReceiveCoinsPage()
	{
	setCurrentWidget(receiveCoinsPage);
	}

	void WalletView::gotoSendCoinsPage(QString addr)
	{
	setCurrentWidget(sendCoinsPage);

	if (!addr.isEmpty())
	sendCoinsPage->setAddress(addr);
	}

	void WalletView::gotoSignMessageTab(QString addr)
	{
	// calls show() in showTab_SM()
	SignVerifyMessageDialog *signVerifyMessageDialog = new SignVerifyMessageDialog(this);
	signVerifyMessageDialog->setAttribute(Qt::WA_DeleteOnClose);
	signVerifyMessageDialog->setModel(walletModel);
	signVerifyMessageDialog->showTab_SM(true);

	if (!addr.isEmpty())
	signVerifyMessageDialog->setAddress_SM(addr);
	}

	void WalletView::gotoVerifyMessageTab(QString addr)
	{
	// calls show() in showTab_VM()
	SignVerifyMessageDialog *signVerifyMessageDialog = new SignVerifyMessageDialog(this);
	signVerifyMessageDialog->setAttribute(Qt::WA_DeleteOnClose);
	signVerifyMessageDialog->setModel(walletModel);
	signVerifyMessageDialog->showTab_VM(true);

	if (!addr.isEmpty())
	signVerifyMessageDialog->setAddress_VM(addr);
	}

	bool WalletView::handlePaymentRequest(const SendCoinsRecipient& recipient)
	{
	- // URI has to be valid
	- if (sendCoinsPage->handlePaymentRequest(recipient))
	- {
	- gotoSendCoinsPage();
	- emit showNormalIfMinimized();
	- return true;
	- }
	- else
	- return false;
	+ return sendCoinsPage->handlePaymentRequest(recipient);
	}

	void WalletView::showOutOfSyncWarning(bool fShow)
	{
	overviewPage->showOutOfSyncWarning(fShow);
	}

	void WalletView::setEncryptionStatus()
	{
	gui->setEncryptionStatus(walletModel->getEncryptionStatus());
	}

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

	setEncryptionStatus();
	}

	void WalletView::backupWallet()
	{
	#if QT_VERSION < 0x050000
	QString saveDir = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
	#else
	QString saveDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
	#endif
	QString filename = QFileDialog::getSaveFileName(this, tr("Backup Wallet"), saveDir, tr("Wallet Data (*.dat)"));
	if (!filename.isEmpty()) {
	if (!walletModel->backupWallet(filename)) {
	- gui->message(tr("Backup Failed"), tr("There was an error trying to save the wallet data to the new location."),
	- CClientUIInterface::MSG_ERROR);
	+ emit message(tr("Backup Failed"), tr("There was an error trying to save the wallet data to the new location."),
	+ CClientUIInterface::MSG_ERROR);
	}
	else
	- gui->message(tr("Backup Successful"), tr("The wallet data was successfully saved to the new location."),
	- CClientUIInterface::MSG_INFORMATION);
	+ emit message(tr("Backup Successful"), tr("The wallet data was successfully saved to the new location."),
	+ CClientUIInterface::MSG_INFORMATION);
	}
	}

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

	void WalletView::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 WalletView::usedSendingAddresses()
	{
	if(!walletModel)
	return;
	AddressBookPage *dlg = new AddressBookPage(AddressBookPage::ForEditing, AddressBookPage::SendingTab, this);
	dlg->setModel(walletModel->getAddressTableModel());
	dlg->setAttribute(Qt::WA_DeleteOnClose);
	dlg->show();
	}

	void WalletView::usedReceivingAddresses()
	{
	if(!walletModel)
	return;
	AddressBookPage *dlg = new AddressBookPage(AddressBookPage::ForEditing, AddressBookPage::ReceivingTab, this);
	dlg->setModel(walletModel->getAddressTableModel());
	dlg->setAttribute(Qt::WA_DeleteOnClose);
	dlg->show();
	}
	diff --git a/src/qt/walletview.h b/src/qt/walletview.h
	index 54451d744..60544cbf8 100644
	--- a/src/qt/walletview.h
	+++ b/src/qt/walletview.h
	@@ -1,110 +1,113 @@
	/*
	* Qt4 bitcoin GUI.
	*
	* W.J. van der Laan 2011-2012
	* The Bitcoin Developers 2011-2013
	*/
	#ifndef WALLETVIEW_H
	#define WALLETVIEW_H

	#include <QStackedWidget>

	class BitcoinGUI;
	class ClientModel;
	class WalletModel;
	class TransactionView;
	class OverviewPage;
	class SendCoinsDialog;
	class ReceiveCoinsDialog;
	class SendCoinsRecipient;
	class SignVerifyMessageDialog;
	class RPCConsole;

	QT_BEGIN_NAMESPACE
	class QLabel;
	class QModelIndex;
	QT_END_NAMESPACE

	/*
	WalletView class. This class represents the view to a single wallet.
	It was added to support multiple wallet functionality. Each wallet gets its own WalletView instance.
	It communicates with both the client and the wallet models to give the user an up-to-date view of the
	current core state.
	*/
	class WalletView : public QStackedWidget
	{
	Q_OBJECT

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

	void setBitcoinGUI(BitcoinGUI *gui);
	/** Set the client model.
	The client model represents the part of the core that communicates with the P2P network, and is wallet-agnostic.
	*/
	void setClientModel(ClientModel *clientModel);
	/** Set the wallet model.
	The wallet model represents a bitcoin wallet, and offers access to the list of transactions, address book and sending
	functionality.
	*/
	void setWalletModel(WalletModel *walletModel);

	bool handlePaymentRequest(const SendCoinsRecipient& recipient);

	void showOutOfSyncWarning(bool fShow);

	private:
	BitcoinGUI *gui;
	ClientModel *clientModel;
	WalletModel *walletModel;

	OverviewPage *overviewPage;
	QWidget *transactionsPage;
	ReceiveCoinsDialog *receiveCoinsPage;
	SendCoinsDialog *sendCoinsPage;

	TransactionView *transactionView;

	public slots:
	/** Switch to overview (home) page */
	void gotoOverviewPage();
	/** Switch to history (transactions) page */
	void gotoHistoryPage();
	/** Switch to receive coins page */
	void gotoReceiveCoinsPage();
	/** Switch to send coins page */
	void gotoSendCoinsPage(QString addr = "");

	/** Show Sign/Verify Message dialog and switch to sign message tab */
	void gotoSignMessageTab(QString addr = "");
	/** Show Sign/Verify Message dialog and switch to verify message tab */
	void gotoVerifyMessageTab(QString addr = "");

	/** Show incoming transaction notification for new transactions.

	The new items are those between start and end inclusive, under the given parent item.
	*/
	void incomingTransaction(const QModelIndex& parent, int start, int /end/);
	/** Encrypt the wallet */
	void encryptWallet(bool status);
	/** Backup the wallet */
	void backupWallet();
	/** Change encrypted wallet passphrase */
	void changePassphrase();
	/** Ask for passphrase to unlock wallet temporarily */
	void unlockWallet();

	/** Show used sending addresses */
	void usedSendingAddresses();
	/** Show used receiving addresses */
	void usedReceivingAddresses();

	void setEncryptionStatus();

	signals:
	/** Signal that we want to show the main window */
	void showNormalIfMinimized();
	+
	+ /** Fired when a message should be reported to the user */
	+ void message(const QString &title, const QString &message, unsigned int style);
	};

	#endif // WALLETVIEW_H

File Metadata

Mime Type: text/x-diff
Expires: Wed, May 21, 23:25 (23 h, 41 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5866148
Default Alt Text: (51 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions