No OneTemporary
Actions

Size

53 KB

Subscribers

None

View Options

	diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
	index d553d8027..cad8c6c08 100644
	--- a/src/qt/bitcoin.cpp
	+++ b/src/qt/bitcoin.cpp
	@@ -1,756 +1,763 @@
	// Copyright (c) 2011-2019 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#include <qt/bitcoin.h>

	#include <chainparams.h>
	#include <config.h>
	#include <httprpc.h>
	#include <interfaces/handler.h>
	#include <interfaces/node.h>
	#include <noui.h>
	#include <qt/bitcoingui.h>
	#include <qt/clientmodel.h>
	#include <qt/guiconstants.h>
	#include <qt/guiutil.h>
	#include <qt/intro.h>
	#include <qt/networkstyle.h>
	#include <qt/optionsmodel.h>
	#include <qt/platformstyle.h>
	#include <qt/splashscreen.h>
	#include <qt/utilitydialog.h>
	#include <qt/winshutdownmonitor.h>
	#include <ui_interface.h>
	#include <uint256.h>
	#include <util/system.h>
	#include <util/threadnames.h>

	#ifdef ENABLE_WALLET
	#include <qt/paymentserver.h>
	#include <qt/walletcontroller.h>
	#include <qt/walletmodel.h>
	#endif // ENABLE_WALLET

	#include <QDebug>
	#include <QLibraryInfo>
	#include <QLocale>
	#include <QMessageBox>
	#include <QSettings>
	#include <QStringList>
	#include <QThread>
	#include <QTimer>
	#include <QTranslator>

	#if defined(QT_STATICPLUGIN)
	#include <QtPlugin>
	#if defined(QT_QPA_PLATFORM_XCB)
	Q_IMPORT_PLUGIN(QXcbIntegrationPlugin);
	#elif defined(QT_QPA_PLATFORM_WINDOWS)
	Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin);
	#elif defined(QT_QPA_PLATFORM_COCOA)
	Q_IMPORT_PLUGIN(QCocoaIntegrationPlugin);
	#endif
	#endif

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

	// Config is non-copyable so we can only register pointers to it
	Q_DECLARE_METATYPE(Config *)

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

	/** Set up translations */
	static void initTranslations(QTranslator &qtTranslatorBase,
	QTranslator &qtTranslator,
	QTranslator &translatorBase,
	QTranslator &translator) {
	// Remove old translators
	QApplication::removeTranslator(&qtTranslatorBase);
	QApplication::removeTranslator(&qtTranslator);
	QApplication::removeTranslator(&translatorBase);
	QApplication::removeTranslator(&translator);

	// Get desired locale (e.g. "de_DE")
	// 1) System default language
	QString lang_territory = GetLangTerritory();

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

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

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

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

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

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

	/* qDebug() message handler --> debug.log */
	void DebugMessageHandler(QtMsgType type, const QMessageLogContext &context,
	const QString &msg) {
	Q_UNUSED(context);
	if (type == QtDebugMsg) {
	LogPrint(BCLog::QT, "GUI: %s\n", msg.toStdString());
	} else {
	LogPrintf("GUI: %s\n", msg.toStdString());
	}
	}

	BitcoinABC::BitcoinABC(interfaces::Node &node) : QObject(), m_node(node) {}

	void BitcoinABC::handleRunawayException(const std::exception *e) {
	PrintExceptionContinue(e, "Runaway exception");
	Q_EMIT runawayException(QString::fromStdString(m_node.getWarnings("gui")));
	}

	void BitcoinABC::initialize(Config config, RPCServer rpcServer,
	HTTPRPCRequestProcessor *httpRPCRequestProcessor) {
	try {
	qDebug() << __func__ << ": Running initialization in thread";
	util::ThreadRename("qt-init");
	bool rv =
	m_node.appInitMain(config, rpcServer, *httpRPCRequestProcessor);
	Q_EMIT initializeResult(rv);
	} catch (const std::exception &e) {
	handleRunawayException(&e);
	} catch (...) {
	handleRunawayException(nullptr);
	}
	}

	void BitcoinABC::shutdown() {
	try {
	qDebug() << __func__ << ": Running Shutdown in thread";
	m_node.appShutdown();
	qDebug() << __func__ << ": Shutdown finished";
	Q_EMIT shutdownResult();
	} catch (const std::exception &e) {
	handleRunawayException(&e);
	} catch (...) {
	handleRunawayException(nullptr);
	}
	}

	static int qt_argc = 1;
	static const char *qt_argv = "bitcoin-qt";

	BitcoinApplication::BitcoinApplication(interfaces::Node &node)
	: QApplication(qt_argc, const_cast<char **>(&qt_argv)), coreThread(nullptr),
	m_node(node), optionsModel(nullptr), clientModel(nullptr),
	window(nullptr), pollShutdownTimer(nullptr), returnValue(0),
	platformStyle(nullptr) {
	setQuitOnLastWindowClosed(false);
	}

	void BitcoinApplication::setupPlatformStyle() {
	// UI per-platform customization
	// This must be done inside the BitcoinApplication constructor, or after it,
	// because PlatformStyle::instantiate requires a QApplication.
	std::string platformName;
	platformName = gArgs.GetArg("-uiplatform", BitcoinGUI::DEFAULT_UIPLATFORM);
	platformStyle =
	PlatformStyle::instantiate(QString::fromStdString(platformName));
	// Fall back to "other" if specified name not found.
	if (!platformStyle) {
	platformStyle = PlatformStyle::instantiate("other");
	}
	assert(platformStyle);
	}

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

	delete window;
	window = nullptr;
	delete optionsModel;
	optionsModel = nullptr;
	delete platformStyle;
	platformStyle = nullptr;
	}

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

	void BitcoinApplication::createOptionsModel(bool resetSettings) {
	optionsModel = new OptionsModel(m_node, nullptr, resetSettings);
	}

	void BitcoinApplication::createWindow(const Config *config,
	const NetworkStyle *networkStyle) {
	window =
	new BitcoinGUI(m_node, config, platformStyle, networkStyle, nullptr);

	pollShutdownTimer = new QTimer(window);
	connect(pollShutdownTimer, &QTimer::timeout, window,
	&BitcoinGUI::detectShutdown);
	}

	void BitcoinApplication::createSplashScreen(const NetworkStyle *networkStyle) {
	SplashScreen *splash = new SplashScreen(m_node, networkStyle);
	// We don't hold a direct pointer to the splash screen after creation, but
	// the splash screen will take care of deleting itself when finish()
	// happens.
	splash->show();
	connect(this, &BitcoinApplication::splashFinished, splash,
	&SplashScreen::finish);
	connect(this, &BitcoinApplication::requestedShutdown, splash,
	&QWidget::close);
	}

	bool BitcoinApplication::baseInitialize(Config &config) {
	return m_node.baseInitialize(config);
	}

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

	/* communication to and from thread */
	connect(executor, &BitcoinABC::initializeResult, this,
	&BitcoinApplication::initializeResult);
	connect(executor, &BitcoinABC::shutdownResult, this,
	&BitcoinApplication::shutdownResult);
	connect(executor, &BitcoinABC::runawayException, this,
	&BitcoinApplication::handleRunawayException);

	// Note on how Qt works: it tries to directly invoke methods if the signal
	// is emitted on the same thread that the target object 'lives' on.
	// But if the target object 'lives' on another thread (executor here does)
	// the SLOT will be invoked asynchronously at a later time in the thread
	// of the target object. So.. we pass a pointer around. If you pass
	// a reference around (even if it's non-const) you'll get Qt generating
	// code to copy-construct the parameter in question (Q_DECLARE_METATYPE
	// and qRegisterMetaType generate this code). For the Config class,
	// which is noncopyable, we can't do this. So.. we have to pass
	// pointers to Config around. Make sure Config &/Config * isn't a
	// temporary (eg it lives somewhere aside from the stack) or this will
	// crash because initialize() gets executed in another thread at some
	// unspecified time (after) requestedInitialize() is emitted!
	connect(this, &BitcoinApplication::requestedInitialize, executor,
	&BitcoinABC::initialize);

	connect(this, &BitcoinApplication::requestedShutdown, executor,
	&BitcoinABC::shutdown);
	/* make sure executor object is deleted in its own thread */
	connect(coreThread, &QThread::finished, executor, &QObject::deleteLater);

	coreThread->start();
	}

	void BitcoinApplication::parameterSetup() {
	// Default printtoconsole to false for the GUI. GUI programs should not
	// print to the console unnecessarily.
	gArgs.SoftSetBoolArg("-printtoconsole", false);

	m_node.initLogging();
	m_node.initParameterInteraction();
	}

	void BitcoinApplication::SetPrune(bool prune, bool force) {
	optionsModel->SetPrune(prune, force);
	}

	void BitcoinApplication::requestInitialize(
	Config &config, RPCServer &rpcServer,
	HTTPRPCRequestProcessor &httpRPCRequestProcessor) {
	qDebug() << __func__ << ": Requesting initialize";
	startThread();
	// IMPORTANT: config must NOT be a reference to a temporary because below
	// signal may be connected to a slot that will be executed as a queued
	// connection in another thread!
	Q_EMIT requestedInitialize(&config, &rpcServer, &httpRPCRequestProcessor);
	}

	void BitcoinApplication::requestShutdown(Config &config) {
	// Show a simple window indicating shutdown status. Do this first as some of
	// the steps may take some time below, for example the RPC console may still
	// be executing a command.
	shutdownWindow.reset(ShutdownWindow::showShutdownWindow(window));

	qDebug() << __func__ << ": Requesting shutdown";
	startThread();
	window->hide();
	// Must disconnect node signals otherwise current thread can deadlock since
	// no event loop is running.
	window->unsubscribeFromCoreSignals();
	// Request node shutdown, which can interrupt long operations, like
	// rescanning a wallet.
	m_node.startShutdown();
	// Unsetting the client model can cause the current thread to wait for node
	// to complete an operation, like wait for a RPC execution to complate.
	window->setClientModel(nullptr);
	pollShutdownTimer->stop();

	delete clientModel;
	clientModel = nullptr;

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

	void BitcoinApplication::initializeResult(bool success) {
	qDebug() << __func__ << ": Initialization result: " << success;
	returnValue = success ? EXIT_SUCCESS : EXIT_FAILURE;
	if (!success) {
	// Make sure splash screen doesn't stick around during shutdown.
	Q_EMIT splashFinished();
	// Exit first main loop invocation.
	quit();
	return;
	}
	// Log this only after AppInitMain finishes, as then logging setup is
	// guaranteed complete.
	qWarning() << "Platform customization:" << platformStyle->getName();
	clientModel = new ClientModel(m_node, optionsModel);
	window->setClientModel(clientModel);
	#ifdef ENABLE_WALLET
	if (WalletModel::isWalletEnabled()) {
	m_wallet_controller =
	new WalletController(m_node, platformStyle, optionsModel, this);
	window->setWalletController(m_wallet_controller);
	if (paymentServer) {
	paymentServer->setOptionsModel(optionsModel);
	#ifdef ENABLE_BIP70
	PaymentServer::LoadRootCAs();
	connect(m_wallet_controller, &WalletController::coinsSent,
	paymentServer, &PaymentServer::fetchPaymentACK);
	#endif
	}
	}
	#endif // ENABLE_WALLET

	// If -min option passed, start window minimized(iconified)
	// or minimized to tray
	if (!gArgs.GetBoolArg("-min", false)) {
	window->show();
	} else if (clientModel->getOptionsModel()->getMinimizeToTray() &&
	window->hasTrayIcon()) {
	// do nothing as the window is managed by the tray icon
	} else {
	window->showMinimized();
	}
	Q_EMIT splashFinished();
	Q_EMIT windowShown(window);

	#ifdef ENABLE_WALLET
	// Now that initialization/startup is done, process any command-line
	// bitcoincash: URIs or payment requests:
	if (paymentServer) {
	connect(paymentServer, &PaymentServer::receivedPaymentRequest, window,
	&BitcoinGUI::handlePaymentRequest);
	connect(window, &BitcoinGUI::receivedURI, paymentServer,
	&PaymentServer::handleURIOrFile);
	connect(paymentServer, &PaymentServer::message,
	[this](const QString &title, const QString &message,
	unsigned int style) {
	window->message(title, message, style);
	});
	QTimer::singleShot(100, paymentServer, &PaymentServer::uiReady);
	}
	#endif

	pollShutdownTimer->start(200);
	}

	void BitcoinApplication::shutdownResult() {
	// Exit second main loop invocation after shutdown finished.
	quit();
	}

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

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

	return window->winId();
	}

	static void SetupUIArgs() {
	#if defined(ENABLE_WALLET) && defined(ENABLE_BIP70)
	gArgs.AddArg("-allowselfsignedrootcertificates",
	strprintf("Allow self signed root certificates (default: %d)",
	DEFAULT_SELFSIGNED_ROOTCERTS),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::GUI);
	#endif
	gArgs.AddArg("-choosedatadir",
	strprintf("Choose data directory on startup (default: %d)",
	DEFAULT_CHOOSE_DATADIR),
	ArgsManager::ALLOW_ANY, OptionsCategory::GUI);
	gArgs.AddArg("-lang=<lang>",
	"Set language, for example \"de_DE\" (default: system locale)",
	ArgsManager::ALLOW_ANY, OptionsCategory::GUI);
	gArgs.AddArg("-min", "Start minimized", ArgsManager::ALLOW_ANY,
	OptionsCategory::GUI);
	gArgs.AddArg(
	"-rootcertificates=<file>",
	"Set SSL root certificates for payment request (default: -system-)",
	ArgsManager::ALLOW_ANY, OptionsCategory::GUI);
	gArgs.AddArg("-splash",
	strprintf("Show splash screen on startup (default: %d)",
	DEFAULT_SPLASHSCREEN),
	ArgsManager::ALLOW_ANY, OptionsCategory::GUI);
	gArgs.AddArg("-resetguisettings", "Reset all settings changed in the GUI",
	ArgsManager::ALLOW_ANY, OptionsCategory::GUI);
	gArgs.AddArg("-uiplatform",
	strprintf("Select platform to customize UI for (one of "
	"windows, macosx, other; default: %s)",
	BitcoinGUI::DEFAULT_UIPLATFORM),
	ArgsManager::ALLOW_ANY \| ArgsManager::DEBUG_ONLY,
	OptionsCategory::GUI);
	}

	static void MigrateSettings() {
	assert(!QApplication::applicationName().isEmpty());

	static const QString legacyAppName("Bitcoin-Qt"),
	#ifdef Q_OS_DARWIN
	// Macs and/or iOS et al use a domain-style name for Settings
	// files. All other platforms use a simple orgname. This
	// difference is documented in the QSettings class documentation.
	legacyOrg("bitcoin.org");
	#else
	legacyOrg("Bitcoin");
	#endif
	QSettings
	// below picks up settings file location based on orgname,appname
	legacy(legacyOrg, legacyAppName),
	// default c'tor below picks up settings file location based on
	// QApplication::applicationName(), et al -- which was already set
	// in main()
	abc;
	#ifdef Q_OS_DARWIN
	// Disable bogus OSX keys from MacOS system-wide prefs that may cloud our
	// judgement ;) (this behavior is also documented in QSettings docs)
	legacy.setFallbacksEnabled(false);
	abc.setFallbacksEnabled(false);
	#endif
	const QStringList legacyKeys(legacy.allKeys());

	// We only migrate settings if we have Core settings but no Bitcoin-ABC
	// settings
	if (!legacyKeys.isEmpty() && abc.allKeys().isEmpty()) {
	for (const QString &key : legacyKeys) {
	// now, copy settings over
	abc.setValue(key, legacy.value(key));
	}
	}
	}

	int GuiMain(int argc, char *argv[]) {
	#ifdef WIN32
	util::WinCmdLineArgs winArgs;
	std::tie(argc, argv) = winArgs.get();
	#endif
	SetupEnvironment();
	util::ThreadSetInternalName("main");

	std::unique_ptr<interfaces::Node> node = interfaces::MakeNode();

	// Subscribe to global signals from core
	std::unique_ptr<interfaces::Handler> handler_message_box =
	node->handleMessageBox(noui_ThreadSafeMessageBox);
	std::unique_ptr<interfaces::Handler> handler_question =
	node->handleQuestion(noui_ThreadSafeQuestion);
	std::unique_ptr<interfaces::Handler> handler_init_message =
	node->handleInitMessage(noui_InitMessage);

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

	/// 1. Basic Qt initialization (not dependent on parameters or
	/// configuration)
	Q_INIT_RESOURCE(bitcoin);
	Q_INIT_RESOURCE(bitcoin_locale);

	// Generate high-dpi pixmaps
	QApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
	QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
	#ifdef Q_OS_MAC
	QApplication::setAttribute(Qt::AA_DontShowIconsInMenus);
	#endif

	BitcoinApplication app(*node);

	// Register meta types used for QMetaObject::invokeMethod
	qRegisterMetaType<bool *>();
	#ifdef ENABLE_WALLET
	qRegisterMetaType<WalletModel *>();
	#endif
	// Need to pass name here as Amount is a typedef (see
	// http://qt-project.org/doc/qt-5/qmetatype.html#qRegisterMetaType)
	// IMPORTANT if it is no longer a typedef use the normal variant above
	qRegisterMetaType<Amount>("Amount");
	qRegisterMetaType<std::function<void()>>("std::function<void()>");
	qRegisterMetaType<QMessageBox::Icon>("QMessageBox::Icon");

	// Need to register any types Qt doesn't know about if you intend
	// to use them with the signal/slot mechanism Qt provides. Even pointers.
	// Note that class Config is noncopyable and so we can't register a
	// non-pointer version of it with Qt, because Qt expects to be able to
	// copy-construct non-pointers to objects for invoking slots
	// behind-the-scenes in the 'Queued' connection case.
	qRegisterMetaType<Config *>();

	/// 2. Parse command-line options. We do this after qt in order to show an
	/// error if there are problems parsing these
	// Command-line options take precedence:
	node->setupServerArgs();
	SetupUIArgs();
	std::string error;
	if (!node->parseParameters(argc, argv, error)) {
	node->initError(
	strprintf("Error parsing command line arguments: %s\n", error));
	// Create a message box, because the gui has neither been created nor
	// has subscribed to core signals
	QMessageBox::critical(
	nullptr, PACKAGE_NAME,
	// message can not be translated because translations have not been
	// initialized
	QString::fromStdString("Error parsing command line arguments: %1.")
	.arg(QString::fromStdString(error)));
	return EXIT_FAILURE;
	}

	// Now that the QApplication is setup and we have parsed our parameters, we
	// can set the platform style
	app.setupPlatformStyle();

	/// 3. Application identification
	// must be set before OptionsModel is initialized or translations are
	// loaded, as it is used to locate QSettings.
	// Note: If you move these calls somewhere else, be sure to bring
	// MigrateSettings() below along for the ride.
	QApplication::setOrganizationName(QAPP_ORG_NAME);
	QApplication::setOrganizationDomain(QAPP_ORG_DOMAIN);
	QApplication::setApplicationName(QAPP_APP_NAME_DEFAULT);
	// Migrate settings from core's/our old GUI settings to Bitcoin ABC
	// only if core's exist but Bitcoin ABC's doesn't.
	// NOTE -- this function needs to be called after the above 3 lines
	// that set the app orgname and app name! If you move the above 3 lines
	// to elsewhere, take this call with you!
	MigrateSettings();

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

	// Show help message immediately after parsing command-line options (for
	// "-lang") and setting locale, but before showing splash screen.
	if (HelpRequested(gArgs) \|\| gArgs.IsArgSet("-version")) {
	HelpMessageDialog help(*node, nullptr, gArgs.IsArgSet("-version"));
	help.showOrPrint();
	return EXIT_SUCCESS;
	}

	/// 5. Now that settings and translations are available, ask user for data
	/// directory. User language is set up: pick a data directory.
	bool did_show_intro = false;
	+ // Intro dialog prune check box
	+ bool prune = false;
	// Gracefully exit if the user cancels
	- if (!Intro::showIfNeeded(*node, did_show_intro)) {
	+ if (!Intro::showIfNeeded(*node, did_show_intro, prune)) {
	return EXIT_SUCCESS;
	}

	/// 6. Determine availability of data directory and parse
	/// bitcoin.conf
	/// - Do not call GetDataDir(true) before this step finishes.
	if (!CheckDataDirOption()) {
	node->initError(
	strprintf("Specified data directory \"%s\" does not exist.\n",
	gArgs.GetArg("-datadir", "")));
	QMessageBox::critical(
	nullptr, PACKAGE_NAME,
	QObject::tr(
	"Error: Specified data directory \"%1\" does not exist.")
	.arg(QString::fromStdString(gArgs.GetArg("-datadir", ""))));
	return EXIT_FAILURE;
	}
	if (!node->readConfigFiles(error)) {
	node->initError(
	strprintf("Error reading configuration file: %s\n", error));
	QMessageBox::critical(
	nullptr, PACKAGE_NAME,
	QObject::tr("Error: Cannot parse configuration file: %1.")
	.arg(QString::fromStdString(error)));
	return EXIT_FAILURE;
	}

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

	// Check for -chain, -testnet or -regtest parameter (Params() calls are only
	// valid after this clause)
	try {
	node->selectParams(gArgs.GetChainName());
	} catch (std::exception &e) {
	node->initError(strprintf("%s\n", e.what()));
	QMessageBox::critical(nullptr, PACKAGE_NAME,
	QObject::tr("Error: %1").arg(e.what()));
	return EXIT_FAILURE;
	}
	#ifdef ENABLE_WALLET
	// Parse URIs on command line -- this can affect Params()
	PaymentServer::ipcParseCommandLine(*node, argc, argv);
	#endif

	QScopedPointer<const NetworkStyle> networkStyle(
	NetworkStyle::instantiate(Params().NetworkIDString()));
	assert(!networkStyle.isNull());
	// Allow for separate UI settings for testnets
	QApplication::setApplicationName(networkStyle->getAppName());
	// Re-initialize translations after changing application name (language in
	// network-specific settings can be different)
	initTranslations(qtTranslatorBase, qtTranslator, translatorBase,
	translator);

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

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

	/// 9. Main GUI initialization
	// Install global event filter that makes sure that long tooltips can be
	// word-wrapped.
	app.installEventFilter(
	new GUIUtil::ToolTipToRichTextFilter(TOOLTIP_WRAP_THRESHOLD, &app));
	#if defined(Q_OS_WIN)
	// Install global event filter for processing Windows session related
	// Windows messages (WM_QUERYENDSESSION and WM_ENDSESSION)
	qApp->installNativeEventFilter(new WinShutdownMonitor());
	#endif
	// Install qDebug() message handler to route to debug.log
	qInstallMessageHandler(DebugMessageHandler);
	// Allow parameter interaction before we create the options model
	app.parameterSetup();
	// Load GUI settings from QSettings
	app.createOptionsModel(gArgs.GetBoolArg("-resetguisettings", false));

	+ if (did_show_intro) {
	+ // Store intro dialog settings other than datadir (network specific)
	+ app.SetPrune(prune, true);
	+ }
	+
	// Get global config
	Config &config = const_cast<Config &>(GetConfig());

	if (gArgs.GetBoolArg("-splash", DEFAULT_SPLASHSCREEN) &&
	!gArgs.GetBoolArg("-min", false)) {
	app.createSplashScreen(networkStyle.data());
	}

	RPCServer rpcServer;
	HTTPRPCRequestProcessor httpRPCRequestProcessor(config, rpcServer);

	try {
	app.createWindow(&config, networkStyle.data());
	// Perform base initialization before spinning up
	// initialization/shutdown thread. This is acceptable because this
	// function only contains steps that are quick to execute, so the GUI
	// thread won't be held up.
	if (!app.baseInitialize(config)) {
	// A dialog with detailed error will have been shown by InitError()
	return EXIT_FAILURE;
	}
	app.requestInitialize(config, rpcServer, httpRPCRequestProcessor);
	#if defined(Q_OS_WIN)
	WinShutdownMonitor::registerShutdownBlockReason(
	QObject::tr("%1 didn't yet exit safely...").arg(PACKAGE_NAME),
	(HWND)app.getMainWinId());
	#endif
	app.exec();
	app.requestShutdown(config);
	app.exec();
	return app.getReturnValue();
	} catch (const std::exception &e) {
	PrintExceptionContinue(&e, "Runaway exception");
	app.handleRunawayException(
	QString::fromStdString(node->getWarnings("gui")));
	} catch (...) {
	PrintExceptionContinue(nullptr, "Runaway exception");
	app.handleRunawayException(
	QString::fromStdString(node->getWarnings("gui")));
	}
	return EXIT_FAILURE;
	}
	diff --git a/src/qt/forms/intro.ui b/src/qt/forms/intro.ui
	index cfdd8482e..f27a4ebe4 100644
	--- a/src/qt/forms/intro.ui
	+++ b/src/qt/forms/intro.ui
	@@ -1,293 +1,303 @@
	<?xml version="1.0" encoding="UTF-8"?>
	<ui version="4.0">
	<class>Intro</class>
	<widget class="QDialog" name="Intro">
	<property name="geometry">
	<rect>
	<x>0</x>
	<y>0</y>
	<width>674</width>
	<height>415</height>
	</rect>
	</property>
	<property name="windowTitle">
	<string>Welcome</string>
	</property>
	<layout class="QVBoxLayout" name="verticalLayout">
	<item>
	<widget class="QLabel" name="welcomeLabel">
	<property name="styleSheet">
	<string notr="true">QLabel { font-style:italic; }</string>
	</property>
	<property name="text">
	<string>Welcome to %1.</string>
	</property>
	<property name="wordWrap">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item>
	<spacer name="verticalSpacer_4">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeType">
	<enum>QSizePolicy::Minimum</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>15</height>
	</size>
	</property>
	</spacer>
	</item>
	<item>
	<widget class="QLabel" name="storageLabel">
	<property name="text">
	<string>As this is the first time the program is launched, you can choose where %1 will store its data.</string>
	</property>
	<property name="wordWrap">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QLabel" name="sizeWarningLabel">
	<property name="wordWrap">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QRadioButton" name="dataDirDefault">
	<property name="text">
	<string>Use the default data directory</string>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QRadioButton" name="dataDirCustom">
	<property name="text">
	<string>Use a custom data directory:</string>
	</property>
	</widget>
	</item>
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout">
	<property name="spacing">
	<number>0</number>
	</property>
	<property name="sizeConstraint">
	<enum>QLayout::SetDefaultConstraint</enum>
	</property>
	<item>
	<spacer name="horizontalSpacer">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	<property name="sizeType">
	<enum>QSizePolicy::Fixed</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>60</width>
	<height>20</height>
	</size>
	</property>
	</spacer>
	</item>
	<item>
	<layout class="QVBoxLayout" name="verticalLayout_2">
	<property name="sizeConstraint">
	<enum>QLayout::SetDefaultConstraint</enum>
	</property>
	<item>
	<layout class="QHBoxLayout" name="horizontalLayout_2">
	<item>
	<widget class="QLineEdit" name="dataDirectory"/>
	</item>
	<item>
	<widget class="QPushButton" name="ellipsisButton">
	<property name="sizePolicy">
	<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
	<horstretch>0</horstretch>
	<verstretch>0</verstretch>
	</sizepolicy>
	</property>
	<property name="maximumSize">
	<size>
	<width>30</width>
	<height>16777215</height>
	</size>
	</property>
	<property name="text">
	<string notr="true">…</string>
	</property>
	<property name="autoDefault">
	<bool>false</bool>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	<item>
	<spacer name="verticalSpacer_3">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeType">
	<enum>QSizePolicy::Fixed</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>5</height>
	</size>
	</property>
	</spacer>
	</item>
	<item>
	<widget class="QLabel" name="freeSpace">
	<property name="sizePolicy">
	<sizepolicy hsizetype="Preferred" vsizetype="Expanding">
	<horstretch>1</horstretch>
	<verstretch>0</verstretch>
	</sizepolicy>
	</property>
	<property name="text">
	<string/>
	</property>
	<property name="wordWrap">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item>
	<spacer name="verticalSpacer_2">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeType">
	<enum>QSizePolicy::Fixed</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>5</height>
	</size>
	</property>
	</spacer>
	</item>
	<item>
	<widget class="QLabel" name="errorMessage">
	<property name="sizePolicy">
	<sizepolicy hsizetype="Preferred" vsizetype="Expanding">
	<horstretch>0</horstretch>
	<verstretch>0</verstretch>
	</sizepolicy>
	</property>
	<property name="textFormat">
	<enum>Qt::RichText</enum>
	</property>
	<property name="wordWrap">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	</layout>
	</item>
	</layout>
	</item>
	<item>
	<widget class="QLabel" name="lblExplanation1">
	<property name="text">
	<string>When you click OK, %1 will begin to download and process the full %4 block chain (%2GB) starting with the earliest transactions in %3 when %4 initially launched.</string>
	</property>
	<property name="wordWrap">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	+ <item>
	+ <widget class="QCheckBox" name="prune">
	+ <property name="toolTip">
	+ <string>Reverting this setting requires re-downloading the entire blockchain. It is faster to download the full chain first and prune it later. Disables some advanced features.</string>
	+ </property>
	+ <property name="text">
	+ <string></string>
	+ </property>
	+ </widget>
	+ </item>
	<item>
	<widget class="QLabel" name="lblExplanation2">
	<property name="text">
	<string>This initial synchronisation is very demanding, and may expose hardware problems with your computer that had previously gone unnoticed. Each time you run %1, it will continue downloading where it left off.</string>
	</property>
	<property name="wordWrap">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item>
	<widget class="QLabel" name="lblExplanation3">
	<property name="text">
	<string>If you have chosen to limit block chain storage (pruning), the historical data must still be downloaded and processed, but will be deleted afterward to keep your disk usage low.</string>
	</property>
	<property name="wordWrap">
	<bool>true</bool>
	</property>
	</widget>
	</item>
	<item>
	<spacer name="verticalSpacer">
	<property name="orientation">
	<enum>Qt::Vertical</enum>
	</property>
	<property name="sizeHint" stdset="0">
	<size>
	<width>20</width>
	<height>40</height>
	</size>
	</property>
	</spacer>
	</item>
	<item>
	<widget class="QDialogButtonBox" name="buttonBox">
	<property name="orientation">
	<enum>Qt::Horizontal</enum>
	</property>
	<property name="standardButtons">
	<set>QDialogButtonBox::Cancel\|QDialogButtonBox::Ok</set>
	</property>
	</widget>
	</item>
	</layout>
	</widget>
	<resources/>
	<connections>
	<connection>
	<sender>buttonBox</sender>
	<signal>accepted()</signal>
	<receiver>Intro</receiver>
	<slot>accept()</slot>
	<hints>
	<hint type="sourcelabel">
	<x>20</x>
	<y>20</y>
	</hint>
	<hint type="destinationlabel">
	<x>20</x>
	<y>20</y>
	</hint>
	</hints>
	</connection>
	<connection>
	<sender>buttonBox</sender>
	<signal>rejected()</signal>
	<receiver>Intro</receiver>
	<slot>reject()</slot>
	<hints>
	<hint type="sourcelabel">
	<x>20</x>
	<y>20</y>
	</hint>
	<hint type="destinationlabel">
	<x>20</x>
	<y>20</y>
	</hint>
	</hints>
	</connection>
	</connections>
	</ui>
	diff --git a/src/qt/intro.cpp b/src/qt/intro.cpp
	index 2ccfd4bcd..33cbf6716 100644
	--- a/src/qt/intro.cpp
	+++ b/src/qt/intro.cpp
	@@ -1,341 +1,353 @@
	// Copyright (c) 2011-2016 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#if defined(HAVE_CONFIG_H)
	#include <config/bitcoin-config.h>
	#endif

	#include <fs.h>
	#include <interfaces/node.h>
	#include <qt/forms/ui_intro.h>
	#include <qt/guiconstants.h>
	#include <qt/guiutil.h>
	#include <qt/intro.h>
	#include <util/system.h>

	#include <QFileDialog>
	#include <QMessageBox>
	#include <QSettings>

	#include <cmath>

	/**
	* Total required space (in GB) depending on user choice (prune, not prune).
	*/
	static uint64_t requiredSpace;

	/* Check free space asynchronously to prevent hanging the UI thread.

	Up to one request to check a path is in flight to this thread; when the
	check()
	function runs, the current path is requested from the associated Intro
	object.
	The reply is sent back through a signal.

	This ensures that no queue of checking requests is built up while the user is
	still entering the path, and that always the most recently entered path is
	checked as
	soon as the thread becomes available.
	*/
	class FreespaceChecker : public QObject {
	Q_OBJECT

	public:
	explicit FreespaceChecker(Intro *intro);

	enum Status { ST_OK, ST_ERROR };

	public Q_SLOTS:
	void check();

	Q_SIGNALS:
	void reply(int status, const QString &message, quint64 available);

	private:
	Intro *intro;
	};

	#include <qt/intro.moc>

	FreespaceChecker::FreespaceChecker(Intro *_intro) {
	this->intro = _intro;
	}

	void FreespaceChecker::check() {
	QString dataDirStr = intro->getPathToCheck();
	fs::path dataDir = GUIUtil::qstringToBoostPath(dataDirStr);
	uint64_t freeBytesAvailable = 0;
	int replyStatus = ST_OK;
	QString replyMessage = tr("A new data directory will be created.");

	/* Find first parent that exists, so that fs::space does not fail */
	fs::path parentDir = dataDir;
	fs::path parentDirOld = fs::path();
	while (parentDir.has_parent_path() && !fs::exists(parentDir)) {
	parentDir = parentDir.parent_path();

	/* Check if we make any progress, break if not to prevent an infinite
	* loop here */
	if (parentDirOld == parentDir) {
	break;
	}

	parentDirOld = parentDir;
	}

	try {
	freeBytesAvailable = fs::space(parentDir).available;
	if (fs::exists(dataDir)) {
	if (fs::is_directory(dataDir)) {
	QString separator = "<code>" + QDir::toNativeSeparators("/") +
	tr("name") + "</code>";
	replyStatus = ST_OK;
	replyMessage = tr("Directory already exists. Add %1 if you "
	"intend to create a new directory here.")
	.arg(separator);
	} else {
	replyStatus = ST_ERROR;
	replyMessage =
	tr("Path already exists, and is not a directory.");
	}
	}
	} catch (const fs::filesystem_error &) {
	/* Parent directory does not exist or is not accessible */
	replyStatus = ST_ERROR;
	replyMessage = tr("Cannot create data directory here.");
	}
	Q_EMIT reply(replyStatus, replyMessage, freeBytesAvailable);
	}

	Intro::Intro(QWidget *parent, uint64_t blockchain_size,
	uint64_t chain_state_size)
	: QDialog(parent), ui(new Ui::Intro), thread(nullptr), signalled(false),
	m_blockchain_size(blockchain_size), m_chain_state_size(chain_state_size) {
	ui->setupUi(this);
	ui->welcomeLabel->setText(ui->welcomeLabel->text().arg(PACKAGE_NAME));
	ui->storageLabel->setText(ui->storageLabel->text().arg(PACKAGE_NAME));

	ui->lblExplanation1->setText(ui->lblExplanation1->text()
	.arg(PACKAGE_NAME)
	.arg(m_blockchain_size)
	.arg(2009)
	.arg(tr("Bitcoin")));
	ui->lblExplanation2->setText(ui->lblExplanation2->text().arg(PACKAGE_NAME));

	uint64_t pruneTarget = std::max<int64_t>(0, gArgs.GetArg("-prune", 0));
	+ // -prune=1 means enabled, above that it's a size in MB
	+ if (pruneTarget > 1) {
	+ ui->prune->setChecked(true);
	+ ui->prune->setEnabled(false);
	+ }
	+ ui->prune->setText(tr("Discard blocks after verification, except most "
	+ "recent %1 GB (prune)")
	+ .arg(pruneTarget ? pruneTarget / 1000 : 2));
	requiredSpace = m_blockchain_size;
	QString storageRequiresMsg =
	tr("At least %1 GB of data will be stored in this directory, and it "
	"will grow over time.");
	if (pruneTarget) {
	uint64_t prunedGBs = std::ceil(pruneTarget * 1024 * 1024.0 / GB_BYTES);
	if (prunedGBs <= requiredSpace) {
	requiredSpace = prunedGBs;
	storageRequiresMsg = tr("Approximately %1 GB of data will be "
	"stored in this directory.");
	}
	ui->lblExplanation3->setVisible(true);
	} else {
	ui->lblExplanation3->setVisible(false);
	}
	requiredSpace += m_chain_state_size;
	ui->sizeWarningLabel->setText(
	tr("%1 will download and store a copy of the Bitcoin block chain.")
	.arg(PACKAGE_NAME) +
	" " + storageRequiresMsg.arg(requiredSpace) + " " +
	tr("The wallet will also be stored in this directory."));
	startThread();
	}

	Intro::~Intro() {
	delete ui;
	/* Ensure thread is finished before it is deleted */
	thread->quit();
	thread->wait();
	}

	QString Intro::getDataDirectory() {
	return ui->dataDirectory->text();
	}

	void Intro::setDataDirectory(const QString &dataDir) {
	ui->dataDirectory->setText(dataDir);
	if (dataDir == getDefaultDataDirectory()) {
	ui->dataDirDefault->setChecked(true);
	ui->dataDirectory->setEnabled(false);
	ui->ellipsisButton->setEnabled(false);
	} else {
	ui->dataDirCustom->setChecked(true);
	ui->dataDirectory->setEnabled(true);
	ui->ellipsisButton->setEnabled(true);
	}
	}

	QString Intro::getDefaultDataDirectory() {
	return GUIUtil::boostPathToQString(GetDefaultDataDir());
	}

	-bool Intro::showIfNeeded(interfaces::Node &node, bool &did_show_intro) {
	+bool Intro::showIfNeeded(interfaces::Node &node, bool &did_show_intro,
	+ bool &prune) {
	did_show_intro = false;

	QSettings settings;
	/* If data directory provided on command line, no need to look at settings
	or show a picking dialog */
	if (!gArgs.GetArg("-datadir", "").empty()) {
	return true;
	}
	/* 1) Default data directory for operating system */
	QString dataDir = getDefaultDataDirectory();
	/* 2) Allow QSettings to override default dir */
	dataDir = settings.value("strDataDir", dataDir).toString();

	if (!fs::exists(GUIUtil::qstringToBoostPath(dataDir)) \|\|
	gArgs.GetBoolArg("-choosedatadir", DEFAULT_CHOOSE_DATADIR) \|\|
	settings.value("fReset", false).toBool() \|\|
	gArgs.GetBoolArg("-resetguisettings", false)) {
	/**
	* Use selectParams here to guarantee Params() can be used by node
	* interface.
	*/
	try {
	node.selectParams(gArgs.GetChainName());
	} catch (const std::exception &) {
	return false;
	}

	/**
	* If current default data directory does not exist, let the user choose
	* one.
	*/
	Intro intro(nullptr, node.getAssumedBlockchainSize(),
	node.getAssumedChainStateSize());
	intro.setDataDirectory(dataDir);
	intro.setWindowIcon(QIcon(":icons/bitcoin"));
	did_show_intro = true;

	while (true) {
	if (!intro.exec()) {
	/* Cancel clicked */
	return false;
	}
	dataDir = intro.getDataDirectory();
	try {
	if (TryCreateDirectories(
	GUIUtil::qstringToBoostPath(dataDir))) {
	// If a new data directory has been created, make wallets
	// subdirectory too
	TryCreateDirectories(GUIUtil::qstringToBoostPath(dataDir) /
	"wallets");
	}
	break;
	} catch (const fs::filesystem_error &) {
	QMessageBox::critical(nullptr, PACKAGE_NAME,
	tr("Error: Specified data directory "
	"\"%1\" cannot be created.")
	.arg(dataDir));
	/* fall through, back to choosing screen */
	}
	}

	+ // Additional preferences:
	+ prune = intro.ui->prune->isChecked();
	+
	settings.setValue("strDataDir", dataDir);
	settings.setValue("fReset", false);
	}
	/* Only override -datadir if different from the default, to make it possible
	* to
	* override -datadir in the bitcoin.conf file in the default data directory
	* (to be consistent with bitcoind behavior)
	*/
	if (dataDir != getDefaultDataDirectory()) {
	// use OS locale for path setting
	node.softSetArg("-datadir",
	GUIUtil::qstringToBoostPath(dataDir).string());
	}
	return true;
	}

	void Intro::setStatus(int status, const QString &message,
	quint64 bytesAvailable) {
	switch (status) {
	case FreespaceChecker::ST_OK:
	ui->errorMessage->setText(message);
	ui->errorMessage->setStyleSheet("");
	break;
	case FreespaceChecker::ST_ERROR:
	ui->errorMessage->setText(tr("Error") + ": " + message);
	ui->errorMessage->setStyleSheet("QLabel { color: #800000 }");
	break;
	}
	/* Indicate number of bytes available */
	if (status == FreespaceChecker::ST_ERROR) {
	ui->freeSpace->setText("");
	} else {
	QString freeString =
	tr("%n GB of free space available", "", bytesAvailable / GB_BYTES);
	if (bytesAvailable < requiredSpace * GB_BYTES) {
	freeString += " " + tr("(of %n GB needed)", "", requiredSpace);
	ui->freeSpace->setStyleSheet("QLabel { color: #800000 }");
	} else {
	ui->freeSpace->setStyleSheet("");
	}
	ui->freeSpace->setText(freeString + ".");
	}
	/* Don't allow confirm in ERROR state */
	ui->buttonBox->button(QDialogButtonBox::Ok)
	->setEnabled(status != FreespaceChecker::ST_ERROR);
	}

	void Intro::on_dataDirectory_textChanged(const QString &dataDirStr) {
	/* Disable OK button until check result comes in */
	ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
	checkPath(dataDirStr);
	}

	void Intro::on_ellipsisButton_clicked() {
	QString dir = QDir::toNativeSeparators(QFileDialog::getExistingDirectory(
	nullptr, "Choose data directory", ui->dataDirectory->text()));
	if (!dir.isEmpty()) {
	ui->dataDirectory->setText(dir);
	}
	}

	void Intro::on_dataDirDefault_clicked() {
	setDataDirectory(getDefaultDataDirectory());
	}

	void Intro::on_dataDirCustom_clicked() {
	ui->dataDirectory->setEnabled(true);
	ui->ellipsisButton->setEnabled(true);
	}

	void Intro::startThread() {
	thread = new QThread(this);
	FreespaceChecker *executor = new FreespaceChecker(this);
	executor->moveToThread(thread);

	connect(executor, &FreespaceChecker::reply, this, &Intro::setStatus);
	connect(this, &Intro::requestCheck, executor, &FreespaceChecker::check);
	/* make sure executor object is deleted in its own thread */
	connect(thread, &QThread::finished, executor, &QObject::deleteLater);

	thread->start();
	}

	void Intro::checkPath(const QString &dataDir) {
	mutex.lock();
	pathToCheck = dataDir;
	if (!signalled) {
	signalled = true;
	Q_EMIT requestCheck();
	}
	mutex.unlock();
	}

	QString Intro::getPathToCheck() {
	QString retval;
	mutex.lock();
	retval = pathToCheck;
	signalled = false; /* new request can be queued now */
	mutex.unlock();
	return retval;
	}
	diff --git a/src/qt/intro.h b/src/qt/intro.h
	index 749fa9714..97d5a7646 100644
	--- a/src/qt/intro.h
	+++ b/src/qt/intro.h
	@@ -1,85 +1,87 @@
	// Copyright (c) 2011-2016 The Bitcoin Core developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef BITCOIN_QT_INTRO_H
	#define BITCOIN_QT_INTRO_H

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

	static const bool DEFAULT_CHOOSE_DATADIR = false;

	class FreespaceChecker;

	namespace interfaces {
	class Node;
	}

	namespace Ui {
	class Intro;
	}

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

	public:
	explicit Intro(QWidget *parent = nullptr, uint64_t blockchain_size = 0,
	uint64_t chain_state_size = 0);
	~Intro();

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

	/**
	* Determine data directory. Let the user choose if the current one doesn't
	* exist.
	+ * Let the user configure additional preferences such as pruning.
	*
	* @returns true if a data directory was selected, false if the user
	* cancelled the selection
	* dialog.
	*
	* @note do NOT call global GetDataDir() before calling this function, this
	* will cause the wrong path to be cached.
	*/
	- static bool showIfNeeded(interfaces::Node &node, bool &did_show_intro);
	+ static bool showIfNeeded(interfaces::Node &node, bool &did_show_intro,
	+ bool &prune);

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

	Q_SIGNALS:
	void requestCheck();

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

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

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

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

	friend class FreespaceChecker;
	};

	#endif // BITCOIN_QT_INTRO_H

File Metadata

Mime Type: text/x-diff
Expires: Thu, Apr 17, 03:23 (13 h, 9 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5508693
Default Alt Text: (53 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions