No OneTemporary
Actions

Size

28 KB

Subscribers

None

View Options

	diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
	index 8c8c73f06..b4e751077 100644
	--- a/src/qt/bitcoin.cpp
	+++ b/src/qt/bitcoin.cpp
	@@ -1,307 +1,307 @@
	/*
	* W.J. van der Laan 2011-2012
	*/
	#include "bitcoingui.h"
	#include "clientmodel.h"
	#include "walletmodel.h"
	#include "optionsmodel.h"
	#include "guiutil.h"
	#include "guiconstants.h"

	#include "init.h"
	#include "ui_interface.h"
	#include "qtipcserver.h"

	#include <QApplication>
	#include <QMessageBox>
	#include <QTextCodec>
	#include <QLocale>
	#include <QTranslator>
	#include <QSplashScreen>
	#include <QLibraryInfo>

	#include <boost/interprocess/ipc/message_queue.hpp>
	#include <boost/algorithm/string/predicate.hpp>

	#if defined(BITCOIN_NEED_QT_PLUGINS) && !defined(_BITCOIN_QT_PLUGINS_INCLUDED)
	#define _BITCOIN_QT_PLUGINS_INCLUDED
	#define __INSURE__
	#include <QtPlugin>
	Q_IMPORT_PLUGIN(qcncodecs)
	Q_IMPORT_PLUGIN(qjpcodecs)
	Q_IMPORT_PLUGIN(qtwcodecs)
	Q_IMPORT_PLUGIN(qkrcodecs)
	Q_IMPORT_PLUGIN(qtaccessiblewidgets)
	#endif

	// Need a global reference for the notifications to find the GUI
	static BitcoinGUI *guiref;
	static QSplashScreen *splashref;

	static void ThreadSafeMessageBox(const std::string& message, const std::string& caption, int style)
	{
	// Message from network thread
	if(guiref)
	{
	bool modal = (style & CClientUIInterface::MODAL);
	// in case of modal message, use blocking connection to wait for user to click OK
	QMetaObject::invokeMethod(guiref, "error",
	modal ? GUIUtil::blockingGUIThreadConnection() : Qt::QueuedConnection,
	Q_ARG(QString, QString::fromStdString(caption)),
	Q_ARG(QString, QString::fromStdString(message)),
	Q_ARG(bool, modal));
	}
	else
	{
	printf("%s: %s\n", caption.c_str(), message.c_str());
	fprintf(stderr, "%s: %s\n", caption.c_str(), message.c_str());
	}
	}

	static bool ThreadSafeAskFee(int64 nFeeRequired, const std::string& strCaption)
	{
	if(!guiref)
	return false;
	if(nFeeRequired < MIN_TX_FEE \|\| nFeeRequired <= nTransactionFee \|\| fDaemon)
	return true;
	bool payFee = false;

	QMetaObject::invokeMethod(guiref, "askFee", GUIUtil::blockingGUIThreadConnection(),
	Q_ARG(qint64, nFeeRequired),
	Q_ARG(bool*, &payFee));

	return payFee;
	}

	static void ThreadSafeHandleURI(const std::string& strURI)
	{
	if(!guiref)
	return;

	QMetaObject::invokeMethod(guiref, "handleURI", GUIUtil::blockingGUIThreadConnection(),
	Q_ARG(QString, QString::fromStdString(strURI)));
	}

	static void InitMessage(const std::string &message)
	{
	if(splashref)
	{
	splashref->showMessage(QString::fromStdString(message), Qt::AlignBottom\|Qt::AlignHCenter, QColor(255,255,200));
	QApplication::instance()->processEvents();
	}
	}

	static void QueueShutdown()
	{
	QMetaObject::invokeMethod(QCoreApplication::instance(), "quit", Qt::QueuedConnection);
	}

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

	/* Handle runaway exceptions. Shows a message box with the problem and quits the program.
	*/
	static void handleRunawayException(std::exception *e)
	{
	PrintExceptionContinue(e, "Runaway exception");
	QMessageBox::critical(0, "Runaway exception", BitcoinGUI::tr("A fatal error occured. Bitcoin can no longer continue safely and will quit.") + QString("\n\n") + QString::fromStdString(strMiscWarning));
	exit(1);
	}

	#ifndef BITCOIN_QT_TEST
	int main(int argc, char *argv[])
	{
	#if !defined(MAC_OSX) && !defined(WIN32)
	// TODO: implement qtipcserver.cpp for Mac and Windows

	// Do this early as we don't want to bother initializing if we are just calling IPC
	for (int i = 1; i < argc; i++)
	{
	if (boost::algorithm::istarts_with(argv[i], "bitcoin:"))
	{
	const char *strURI = argv[i];
	try {
	boost::interprocess::message_queue mq(boost::interprocess::open_only, BITCOINURI_QUEUE_NAME);
	if(mq.try_send(strURI, strlen(strURI), 0))
	exit(0);
	else
	break;
	}
	catch (boost::interprocess::interprocess_exception &ex) {
	break;
	}
	}
	}
	#endif

	// Internal string conversion is all UTF-8
	QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
	QTextCodec::setCodecForCStrings(QTextCodec::codecForTr());

	Q_INIT_RESOURCE(bitcoin);
	QApplication app(argc, argv);

	// Install global event filter that makes sure that long tooltips can be word-wrapped
	app.installEventFilter(new GUIUtil::ToolTipToRichTextFilter(TOOLTIP_WRAP_THRESHOLD, &app));

	// Command-line options take precedence:
	ParseParameters(argc, argv);

	// ... then bitcoin.conf:
	if (!boost::filesystem::is_directory(GetDataDir(false)))
	{
	fprintf(stderr, "Error: Specified directory does not exist\n");
	return 1;
	}
	ReadConfigFile(mapArgs, mapMultiArgs);

	// Application identification (must be set before OptionsModel is initialized,
	// as it is used to locate QSettings)
	app.setOrganizationName("Bitcoin");
	app.setOrganizationDomain("bitcoin.org");
	if(GetBoolArg("-testnet")) // Separate UI settings for testnet
	app.setApplicationName("Bitcoin-Qt-testnet");
	else
	app.setApplicationName("Bitcoin-Qt");

	// ... then GUI settings:
	OptionsModel optionsModel;

	// Get desired locale (e.g. "de_DE") from command line or use system locale
	QString lang_territory = QString::fromStdString(GetArg("-lang", QLocale::system().name().toStdString()));
	QString lang = lang_territory;
	// Convert to "de" only by truncating "_DE"
	lang.truncate(lang_territory.lastIndexOf('_'));

	QTranslator qtTranslatorBase, qtTranslator, translatorBase, translator;
	// 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)))
	app.installTranslator(&qtTranslatorBase);

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

	// Load e.g. bitcoin_de.qm (shortcut "de" needs to be defined in bitcoin.qrc)
	if (translatorBase.load(lang, ":/translations/"))
	app.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/"))
	app.installTranslator(&translator);

	// Subscribe to global signals from core
	uiInterface.ThreadSafeMessageBox.connect(ThreadSafeMessageBox);
	uiInterface.ThreadSafeAskFee.connect(ThreadSafeAskFee);
	uiInterface.ThreadSafeHandleURI.connect(ThreadSafeHandleURI);
	uiInterface.InitMessage.connect(InitMessage);
	uiInterface.QueueShutdown.connect(QueueShutdown);
	uiInterface.Translate.connect(Translate);

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

	QSplashScreen splash(QPixmap(":/images/splash"), 0);
	if (GetBoolArg("-splash", true) && !GetBoolArg("-min"))
	{
	splash.show();
	splash.setAutoFillBackground(true);
	splashref = &splash;
	}

	app.processEvents();

	app.setQuitOnLastWindowClosed(false);

	try
	{
	// Regenerate startup link, to fix links to old versions
	if (GUIUtil::GetStartOnSystemStartup())
	GUIUtil::SetStartOnSystemStartup(true);

	BitcoinGUI window;
	guiref = &window;
	if(AppInit2())
	{
	{
	// Put this in a block, so that the Model objects are cleaned up before
	// calling Shutdown().

	optionsModel.Upgrade(); // Must be done after AppInit2

	if (splashref)
	splash.finish(&window);

	ClientModel clientModel(&optionsModel);
	WalletModel walletModel(pwalletMain, &optionsModel);

	window.setClientModel(&clientModel);
	window.setWalletModel(&walletModel);

	// If -min option passed, start window minimized.
	if(GetBoolArg("-min"))
	{
	window.showMinimized();
	}
	else
	{
	window.show();
	}
	#if !defined(MAC_OSX) && !defined(WIN32)
	// TODO: implement qtipcserver.cpp for Mac and Windows

	// Place this here as guiref has to be defined if we dont want to lose URIs
	ipcInit();

	// Check for URI in argv
	for (int i = 1; i < argc; i++)
	{
	if (boost::algorithm::istarts_with(argv[i], "bitcoin:"))
	{
	const char *strURI = argv[i];
	try {
	boost::interprocess::message_queue mq(boost::interprocess::open_only, BITCOINURI_QUEUE_NAME);
	mq.try_send(strURI, strlen(strURI), 0);
	}
	catch (boost::interprocess::interprocess_exception &ex) {
	}
	}
	}
	#endif
	app.exec();

	window.hide();
	window.setClientModel(0);
	window.setWalletModel(0);
	guiref = 0;
	}
	// Shutdown the core and it's threads, but don't exit Bitcoin-Qt here
	Shutdown(NULL);
	}
	else
	{
	return 1;
	}
	} catch (std::exception& e) {
	handleRunawayException(&e);
	} catch (...) {
	handleRunawayException(NULL);
	}
	return 0;
	}
	#endif // BITCOIN_QT_TEST
	diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
	index a8c232885..50ed2eed0 100644
	--- a/src/qt/guiutil.cpp
	+++ b/src/qt/guiutil.cpp
	@@ -1,457 +1,463 @@
	#include "guiutil.h"
	#include "bitcoinaddressvalidator.h"
	#include "walletmodel.h"
	#include "bitcoinunits.h"
	#include "util.h"
	#include "init.h"
	#include "base58.h"

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

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

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

	namespace GUIUtil {

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

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

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

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

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

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

	// check if the address is valid
	CBitcoinAddress addressFromUri(uri.path().toStdString());
	if (!addressFromUri.IsValid())
	return false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	}

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

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

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

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

	if (fAutoStart)
	{
	CoInitialize(NULL);

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

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

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

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

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

	#elif defined(LINUX)

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

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

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

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

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

	return true;
	}

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

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

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

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

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

	#endif

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

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

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

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

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

	} // namespace GUIUtil

	diff --git a/src/qt/guiutil.h b/src/qt/guiutil.h
	index ca0634851..024069550 100644
	--- a/src/qt/guiutil.h
	+++ b/src/qt/guiutil.h
	@@ -1,116 +1,120 @@
	#ifndef GUIUTIL_H
	#define GUIUTIL_H

	#include <QString>
	#include <QObject>
	#include <QMessageBox>

	QT_BEGIN_NAMESPACE
	class QFont;
	class QLineEdit;
	class QWidget;
	class QDateTime;
	class QUrl;
	class QAbstractItemView;
	QT_END_NAMESPACE
	class SendCoinsRecipient;

	/** Utility functions used by the Bitcoin Qt UI.
	*/
	namespace GUIUtil
	{
	// Create human-readable string from date
	QString dateTimeStr(const QDateTime &datetime);
	QString dateTimeStr(qint64 nTime);

	// Render Bitcoin addresses in monospace font
	QFont bitcoinAddressFont();

	// Set up widgets for address and amounts
	void setupAddressWidget(QLineEdit widget, QWidget parent);
	void setupAmountWidget(QLineEdit widget, QWidget parent);

	// Parse "bitcoin:" URI into recipient object, return true on succesful parsing
	// See Bitcoin URI definition discussion here: https://bitcointalk.org/index.php?topic=33490.0
	bool parseBitcoinURI(const QUrl &uri, SendCoinsRecipient *out);
	bool parseBitcoinURI(QString uri, SendCoinsRecipient *out);

	// HTML escaping for rich text controls
	QString HtmlEscape(const QString& str, bool fMultiLine=false);
	QString HtmlEscape(const std::string& str, bool fMultiLine=false);

	/** Copy a field of the currently selected entry of a view to the clipboard. Does nothing if nothing
	is selected.
	@param[in] column Data column to extract from the model
	@param[in] role Data role to extract from the model
	@see TransactionView::copyLabel, TransactionView::copyAmount, TransactionView::copyAddress
	*/
	void copyEntryData(QAbstractItemView *view, int column, int role=Qt::EditRole);

	/** Get save file name, mimics QFileDialog::getSaveFileName, except that it appends a default suffix
	when no suffix is provided by the user.

	@param[in] parent Parent window (or 0)
	@param[in] caption Window caption (or empty, for default)
	@param[in] dir Starting directory (or empty, to default to documents directory)
	@param[in] filter Filter specification such as "Comma Separated Files (*.csv)"
	@param[out] selectedSuffixOut Pointer to return the suffix (file type) that was selected (or 0).
	Can be useful when choosing the save file format based on suffix.
	*/
	QString getSaveFileName(QWidget *parent=0, const QString &caption=QString(),
	const QString &dir=QString(), const QString &filter=QString(),
	QString *selectedSuffixOut=0);

	/** Get connection type to call object slot in GUI thread with invokeMethod. The call will be blocking.

	@returns If called from the GUI thread, return a Qt::DirectConnection.
	If called from another thread, return a Qt::BlockingQueuedConnection.
	*/
	Qt::ConnectionType blockingGUIThreadConnection();

	// Determine whether a widget is hidden behind other windows
	bool isObscured(QWidget *w);

	// Open debug.log
	void openDebugLogfile();

	/** Qt event filter that intercepts ToolTipChange events, and replaces the tooltip with a rich text
	representation if needed. This assures that Qt can word-wrap long tooltip messages.
	Tooltips longer than the provided size threshold (in characters) are wrapped.
	*/
	class ToolTipToRichTextFilter : public QObject
	{
	Q_OBJECT

	public:
	explicit ToolTipToRichTextFilter(int size_threshold, QObject *parent = 0);

	protected:
	bool eventFilter(QObject obj, QEvent evt);

	private:
	int size_threshold;
	};

	bool GetStartOnSystemStartup();
	bool SetStartOnSystemStartup(bool fAutoStart);

	/** Help message for Bitcoin-Qt, shown with --help. */
	class HelpMessageBox : public QMessageBox
	{
	Q_OBJECT

	public:
	HelpMessageBox(QWidget *parent = 0);

	- void exec();
	+ /** Show message box or print help message to standard output, based on operating system. */
	+ void showOrPrint();
	+
	+ /** Print help message to console */
	+ void printToConsole();

	private:
	QString header;
	QString coreOptions;
	QString uiOptions;
	};

	} // namespace GUIUtil

	#endif // GUIUTIL_H

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 10:39 (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187278
Default Alt Text: (28 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions