496a0c31c9
1c860ce Autobackup refactoring and improvements: - make nWalletBackups globally accessable - move autobackup code from init.cpp to walletdb.cpp, see AutoBackupWallet function - refactor autobackup code to warn user if autobackup failed instead of silently ignoring this fact - refactor autobackup code to be able to backup fresh new wallet right after it was created, add this functionality to init sequence - add new cmd-line option "-walletbackupsdir" to specify full path to directory for automatic wallet backups, see GetBackupsDir function 0ba1548 autobackup in PS: - add nKeysLeftSinceAutoBackup to have some idea how many keys in keypool are more or less safe, show it in advanced PS UI mode and in rpc output for privatesend and getwalletinfo commands - add autobackups support in PrivateSend mixing both in daemon and QT mode, warn user if number of keys left since last autobackup is very low or even stop mixing completely if it's too low f3a2494 Warn about a special case - less than 60 seconds between restarts i.e. backup file name is the same as previos one. Continue and do not disable automatic backups in this case . e7b56bd Refactor to address locked wallets issue, replenish keypool and re-initialize autobackup on unlock (only if was disabled due to keypool issue) Adjust few message strings.
1003 lines
31 KiB
C++
1003 lines
31 KiB
C++
// Copyright (c) 2011-2015 The Bitcoin Core developers
|
|
// Copyright (c) 2014-2016 The Dash Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "guiutil.h"
|
|
|
|
#include "bitcoinaddressvalidator.h"
|
|
#include "bitcoinunits.h"
|
|
#include "qvalidatedlineedit.h"
|
|
#include "walletmodel.h"
|
|
|
|
#include "primitives/transaction.h"
|
|
#include "init.h"
|
|
#include "main.h" // For minRelayTxFee
|
|
#include "protocol.h"
|
|
#include "script/script.h"
|
|
#include "script/standard.h"
|
|
#include "util.h"
|
|
|
|
#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 "shellapi.h"
|
|
#include "shlobj.h"
|
|
#include "shlwapi.h"
|
|
#endif
|
|
|
|
#include <boost/filesystem.hpp>
|
|
#include <boost/filesystem/fstream.hpp>
|
|
#if BOOST_FILESYSTEM_VERSION >= 3
|
|
#include <boost/filesystem/detail/utf8_codecvt_facet.hpp>
|
|
#endif
|
|
#include <boost/scoped_array.hpp>
|
|
|
|
#include <QAbstractItemView>
|
|
#include <QApplication>
|
|
#include <QClipboard>
|
|
#include <QDateTime>
|
|
#include <QDesktopServices>
|
|
#include <QDesktopWidget>
|
|
#include <QDoubleValidator>
|
|
#include <QFileDialog>
|
|
#include <QFont>
|
|
#include <QLineEdit>
|
|
#include <QSettings>
|
|
#include <QTextDocument> // for Qt::mightBeRichText
|
|
#include <QThread>
|
|
|
|
#if QT_VERSION < 0x050000
|
|
#include <QUrl>
|
|
#else
|
|
#include <QUrlQuery>
|
|
#endif
|
|
|
|
#if QT_VERSION >= 0x50200
|
|
#include <QFontDatabase>
|
|
#endif
|
|
|
|
#if BOOST_FILESYSTEM_VERSION >= 3
|
|
static boost::filesystem::detail::utf8_codecvt_facet utf8;
|
|
#endif
|
|
|
|
#if defined(Q_OS_MAC)
|
|
extern double NSAppKitVersionNumber;
|
|
#if !defined(NSAppKitVersionNumber10_8)
|
|
#define NSAppKitVersionNumber10_8 1187
|
|
#endif
|
|
#if !defined(NSAppKitVersionNumber10_9)
|
|
#define NSAppKitVersionNumber10_9 1265
|
|
#endif
|
|
#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 fixedPitchFont()
|
|
{
|
|
#if QT_VERSION >= 0x50200
|
|
return QFontDatabase::systemFont(QFontDatabase::FixedFont);
|
|
#else
|
|
QFont font("Monospace");
|
|
#if QT_VERSION >= 0x040800
|
|
font.setStyleHint(QFont::Monospace);
|
|
#else
|
|
font.setStyleHint(QFont::TypeWriter);
|
|
#endif
|
|
return font;
|
|
#endif
|
|
}
|
|
|
|
void setupAddressWidget(QValidatedLineEdit *widget, QWidget *parent)
|
|
{
|
|
parent->setFocusProxy(widget);
|
|
|
|
widget->setFont(fixedPitchFont());
|
|
#if QT_VERSION >= 0x040700
|
|
// We don't want translators to use own addresses in translations
|
|
// and this is the only place, where this address is supplied.
|
|
widget->setPlaceholderText(QObject::tr("Enter a Dash address (e.g. %1)").arg("XwnLY9Tf7Zsef8gMGL2fhWA9ZmMjt4KPwg"));
|
|
#endif
|
|
widget->setValidator(new BitcoinAddressEntryValidator(parent));
|
|
widget->setCheckValidator(new BitcoinAddressCheckValidator(parent));
|
|
}
|
|
|
|
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)
|
|
{
|
|
// return if URI is not valid or is no dash: URI
|
|
if(!uri.isValid() || uri.scheme() != QString("dash"))
|
|
return false;
|
|
|
|
SendCoinsRecipient rv;
|
|
rv.address = uri.path();
|
|
// Trim any following forward slash which may have been added by the OS
|
|
if (rv.address.endsWith("/")) {
|
|
rv.address.truncate(rv.address.length() - 1);
|
|
}
|
|
rv.amount = 0;
|
|
|
|
#if QT_VERSION < 0x050000
|
|
QList<QPair<QString, QString> > items = uri.queryItems();
|
|
#else
|
|
QUrlQuery uriQuery(uri);
|
|
QList<QPair<QString, QString> > items = uriQuery.queryItems();
|
|
#endif
|
|
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;
|
|
}
|
|
if (i->first == "message")
|
|
{
|
|
rv.message = i->second;
|
|
fShouldReturnFalse = false;
|
|
}
|
|
else if (i->first == "amount")
|
|
{
|
|
if(!i->second.isEmpty())
|
|
{
|
|
if(!BitcoinUnits::parse(BitcoinUnits::DASH, 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 dash:// to dash:
|
|
//
|
|
// Cannot handle this later, because dash:// will cause Qt to see the part after // as host,
|
|
// which will lower-case it (and thus invalidate the address).
|
|
if(uri.startsWith("dash://", Qt::CaseInsensitive))
|
|
{
|
|
uri.replace(0, 7, "dash:");
|
|
}
|
|
QUrl uriInstance(uri);
|
|
return parseBitcoinURI(uriInstance, out);
|
|
}
|
|
|
|
QString formatBitcoinURI(const SendCoinsRecipient &info)
|
|
{
|
|
QString ret = QString("dash:%1").arg(info.address);
|
|
int paramCount = 0;
|
|
|
|
if (info.amount)
|
|
{
|
|
ret += QString("?amount=%1").arg(BitcoinUnits::format(BitcoinUnits::DASH, info.amount, false, BitcoinUnits::separatorNever));
|
|
paramCount++;
|
|
}
|
|
|
|
if (!info.label.isEmpty())
|
|
{
|
|
QString lbl(QUrl::toPercentEncoding(info.label));
|
|
ret += QString("%1label=%2").arg(paramCount == 0 ? "?" : "&").arg(lbl);
|
|
paramCount++;
|
|
}
|
|
|
|
if (!info.message.isEmpty())
|
|
{
|
|
QString msg(QUrl::toPercentEncoding(info.message));;
|
|
ret += QString("%1message=%2").arg(paramCount == 0 ? "?" : "&").arg(msg);
|
|
paramCount++;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool isDust(const QString& address, const CAmount& amount)
|
|
{
|
|
CTxDestination dest = CBitcoinAddress(address.toStdString()).Get();
|
|
CScript script = GetScriptForDestination(dest);
|
|
CTxOut txOut(amount, script);
|
|
return txOut.IsDust(::minRelayTxFee);
|
|
}
|
|
|
|
QString HtmlEscape(const QString& str, bool fMultiLine)
|
|
{
|
|
#if QT_VERSION < 0x050000
|
|
QString escaped = Qt::escape(str);
|
|
#else
|
|
QString escaped = str.toHtmlEscaped();
|
|
#endif
|
|
escaped = escaped.replace(" ", " ");
|
|
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
|
|
setClipboard(selection.at(0).data(role).toString());
|
|
}
|
|
}
|
|
|
|
QString getEntryData(QAbstractItemView *view, int column, int role)
|
|
{
|
|
if(!view || !view->selectionModel())
|
|
return QString();
|
|
QModelIndexList selection = view->selectionModel()->selectedRows(column);
|
|
|
|
if(!selection.isEmpty()) {
|
|
// Return first item
|
|
return (selection.at(0).data(role).toString());
|
|
}
|
|
return QString();
|
|
}
|
|
|
|
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
|
|
{
|
|
#if QT_VERSION < 0x050000
|
|
myDir = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
|
|
#else
|
|
myDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
myDir = dir;
|
|
}
|
|
/* Directly convert path to native OS path separators */
|
|
QString result = QDir::toNativeSeparators(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;
|
|
}
|
|
|
|
QString getOpenFileName(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
|
|
{
|
|
#if QT_VERSION < 0x050000
|
|
myDir = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
|
|
#else
|
|
myDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
myDir = dir;
|
|
}
|
|
/* Directly convert path to native OS path separators */
|
|
QString result = QDir::toNativeSeparators(QFileDialog::getOpenFileName(parent, caption, myDir, filter, &selectedFilter));
|
|
|
|
if(selectedSuffixOut)
|
|
{
|
|
/* 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);
|
|
}
|
|
*selectedSuffixOut = selectedSuffix;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
Qt::ConnectionType blockingGUIThreadConnection()
|
|
{
|
|
if(QThread::currentThread() != qApp->thread())
|
|
{
|
|
return Qt::BlockingQueuedConnection;
|
|
}
|
|
else
|
|
{
|
|
return Qt::DirectConnection;
|
|
}
|
|
}
|
|
|
|
bool checkPoint(const QPoint &p, const QWidget *w)
|
|
{
|
|
QWidget *atW = QApplication::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(boostPathToQString(pathDebug)));
|
|
}
|
|
|
|
void openConfigfile()
|
|
{
|
|
boost::filesystem::path pathConfig = GetConfigFile();
|
|
|
|
/* Open dash.conf with the associated application */
|
|
if (boost::filesystem::exists(pathConfig))
|
|
QDesktopServices::openUrl(QUrl::fromLocalFile(boostPathToQString(pathConfig)));
|
|
}
|
|
|
|
void openMNConfigfile()
|
|
{
|
|
boost::filesystem::path pathConfig = GetMasternodeConfigFile();
|
|
|
|
/* Open masternode.conf with the associated application */
|
|
if (boost::filesystem::exists(pathConfig))
|
|
QDesktopServices::openUrl(QUrl::fromLocalFile(boostPathToQString(pathConfig)));
|
|
}
|
|
|
|
void showBackups()
|
|
{
|
|
boost::filesystem::path backupsDir = GetBackupsDir();
|
|
|
|
/* Open folder with default browser */
|
|
if (boost::filesystem::exists(backupsDir))
|
|
QDesktopServices::openUrl(QUrl::fromLocalFile(boostPathToQString(backupsDir)));
|
|
}
|
|
|
|
void SubstituteFonts(const QString& language)
|
|
{
|
|
#if defined(Q_OS_MAC)
|
|
// Background:
|
|
// OSX's default font changed in 10.9 and Qt is unable to find it with its
|
|
// usual fallback methods when building against the 10.7 sdk or lower.
|
|
// The 10.8 SDK added a function to let it find the correct fallback font.
|
|
// If this fallback is not properly loaded, some characters may fail to
|
|
// render correctly.
|
|
//
|
|
// The same thing happened with 10.10. .Helvetica Neue DeskInterface is now default.
|
|
//
|
|
// Solution: If building with the 10.7 SDK or lower and the user's platform
|
|
// is 10.9 or higher at runtime, substitute the correct font. This needs to
|
|
// happen before the QApplication is created.
|
|
#if defined(MAC_OS_X_VERSION_MAX_ALLOWED) && MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_8
|
|
if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_8)
|
|
{
|
|
if (floor(NSAppKitVersionNumber) <= NSAppKitVersionNumber10_9)
|
|
/* On a 10.9 - 10.9.x system */
|
|
QFont::insertSubstitution(".Lucida Grande UI", "Lucida Grande");
|
|
else
|
|
{
|
|
/* 10.10 or later system */
|
|
if (language == "zh_CN" || language == "zh_TW" || language == "zh_HK") // traditional or simplified Chinese
|
|
QFont::insertSubstitution(".Helvetica Neue DeskInterface", "Heiti SC");
|
|
else if (language == "ja") // Japanesee
|
|
QFont::insertSubstitution(".Helvetica Neue DeskInterface", "Songti SC");
|
|
else
|
|
QFont::insertSubstitution(".Helvetica Neue DeskInterface", "Lucida Grande");
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
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"))
|
|
{
|
|
// Escape the current message as HTML and replace \n by <br> if it's not rich text
|
|
if(!Qt::mightBeRichText(tooltip))
|
|
tooltip = HtmlEscape(tooltip, true);
|
|
// Envelop with <qt></qt> to make sure Qt detects every tooltip as rich text
|
|
// and style='white-space:pre' to preserve line composition
|
|
tooltip = "<qt style='white-space:pre'>" + tooltip + "</qt>";
|
|
widget->setToolTip(tooltip);
|
|
return true;
|
|
}
|
|
}
|
|
return QObject::eventFilter(obj, evt);
|
|
}
|
|
|
|
void TableViewLastColumnResizingFixer::connectViewHeadersSignals()
|
|
{
|
|
connect(tableView->horizontalHeader(), SIGNAL(sectionResized(int,int,int)), this, SLOT(on_sectionResized(int,int,int)));
|
|
connect(tableView->horizontalHeader(), SIGNAL(geometriesChanged()), this, SLOT(on_geometriesChanged()));
|
|
}
|
|
|
|
// We need to disconnect these while handling the resize events, otherwise we can enter infinite loops.
|
|
void TableViewLastColumnResizingFixer::disconnectViewHeadersSignals()
|
|
{
|
|
disconnect(tableView->horizontalHeader(), SIGNAL(sectionResized(int,int,int)), this, SLOT(on_sectionResized(int,int,int)));
|
|
disconnect(tableView->horizontalHeader(), SIGNAL(geometriesChanged()), this, SLOT(on_geometriesChanged()));
|
|
}
|
|
|
|
// Setup the resize mode, handles compatibility for Qt5 and below as the method signatures changed.
|
|
// Refactored here for readability.
|
|
void TableViewLastColumnResizingFixer::setViewHeaderResizeMode(int logicalIndex, QHeaderView::ResizeMode resizeMode)
|
|
{
|
|
#if QT_VERSION < 0x050000
|
|
tableView->horizontalHeader()->setResizeMode(logicalIndex, resizeMode);
|
|
#else
|
|
tableView->horizontalHeader()->setSectionResizeMode(logicalIndex, resizeMode);
|
|
#endif
|
|
}
|
|
|
|
void TableViewLastColumnResizingFixer::resizeColumn(int nColumnIndex, int width)
|
|
{
|
|
tableView->setColumnWidth(nColumnIndex, width);
|
|
tableView->horizontalHeader()->resizeSection(nColumnIndex, width);
|
|
}
|
|
|
|
int TableViewLastColumnResizingFixer::getColumnsWidth()
|
|
{
|
|
int nColumnsWidthSum = 0;
|
|
for (int i = 0; i < columnCount; i++)
|
|
{
|
|
nColumnsWidthSum += tableView->horizontalHeader()->sectionSize(i);
|
|
}
|
|
return nColumnsWidthSum;
|
|
}
|
|
|
|
int TableViewLastColumnResizingFixer::getAvailableWidthForColumn(int column)
|
|
{
|
|
int nResult = lastColumnMinimumWidth;
|
|
int nTableWidth = tableView->horizontalHeader()->width();
|
|
|
|
if (nTableWidth > 0)
|
|
{
|
|
int nOtherColsWidth = getColumnsWidth() - tableView->horizontalHeader()->sectionSize(column);
|
|
nResult = std::max(nResult, nTableWidth - nOtherColsWidth);
|
|
}
|
|
|
|
return nResult;
|
|
}
|
|
|
|
// Make sure we don't make the columns wider than the tables viewport width.
|
|
void TableViewLastColumnResizingFixer::adjustTableColumnsWidth()
|
|
{
|
|
disconnectViewHeadersSignals();
|
|
resizeColumn(lastColumnIndex, getAvailableWidthForColumn(lastColumnIndex));
|
|
connectViewHeadersSignals();
|
|
|
|
int nTableWidth = tableView->horizontalHeader()->width();
|
|
int nColsWidth = getColumnsWidth();
|
|
if (nColsWidth > nTableWidth)
|
|
{
|
|
resizeColumn(secondToLastColumnIndex,getAvailableWidthForColumn(secondToLastColumnIndex));
|
|
}
|
|
}
|
|
|
|
// Make column use all the space available, useful during window resizing.
|
|
void TableViewLastColumnResizingFixer::stretchColumnWidth(int column)
|
|
{
|
|
disconnectViewHeadersSignals();
|
|
resizeColumn(column, getAvailableWidthForColumn(column));
|
|
connectViewHeadersSignals();
|
|
}
|
|
|
|
// When a section is resized this is a slot-proxy for ajustAmountColumnWidth().
|
|
void TableViewLastColumnResizingFixer::on_sectionResized(int logicalIndex, int oldSize, int newSize)
|
|
{
|
|
adjustTableColumnsWidth();
|
|
int remainingWidth = getAvailableWidthForColumn(logicalIndex);
|
|
if (newSize > remainingWidth)
|
|
{
|
|
resizeColumn(logicalIndex, remainingWidth);
|
|
}
|
|
}
|
|
|
|
// When the tabless geometry is ready, we manually perform the stretch of the "Message" column,
|
|
// as the "Stretch" resize mode does not allow for interactive resizing.
|
|
void TableViewLastColumnResizingFixer::on_geometriesChanged()
|
|
{
|
|
if ((getColumnsWidth() - this->tableView->horizontalHeader()->width()) != 0)
|
|
{
|
|
disconnectViewHeadersSignals();
|
|
resizeColumn(secondToLastColumnIndex, getAvailableWidthForColumn(secondToLastColumnIndex));
|
|
connectViewHeadersSignals();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Initializes all internal variables and prepares the
|
|
* the resize modes of the last 2 columns of the table and
|
|
*/
|
|
TableViewLastColumnResizingFixer::TableViewLastColumnResizingFixer(QTableView* table, int lastColMinimumWidth, int allColsMinimumWidth) :
|
|
tableView(table),
|
|
lastColumnMinimumWidth(lastColMinimumWidth),
|
|
allColumnsMinimumWidth(allColsMinimumWidth)
|
|
{
|
|
columnCount = tableView->horizontalHeader()->count();
|
|
lastColumnIndex = columnCount - 1;
|
|
secondToLastColumnIndex = columnCount - 2;
|
|
tableView->horizontalHeader()->setMinimumSectionSize(allColumnsMinimumWidth);
|
|
setViewHeaderResizeMode(secondToLastColumnIndex, QHeaderView::Interactive);
|
|
setViewHeaderResizeMode(lastColumnIndex, QHeaderView::Interactive);
|
|
}
|
|
|
|
#ifdef WIN32
|
|
boost::filesystem::path static StartupShortcutPath()
|
|
{
|
|
std::string chain = ChainNameFromCommandLine();
|
|
if (chain == CBaseChainParams::MAIN)
|
|
return GetSpecialFolderPath(CSIDL_STARTUP) / "Dash.lnk";
|
|
if (chain == CBaseChainParams::TESTNET) // Remove this special case when CBaseChainParams::TESTNET = "testnet4"
|
|
return GetSpecialFolderPath(CSIDL_STARTUP) / "Dash (testnet).lnk";
|
|
return GetSpecialFolderPath(CSIDL_STARTUP) / strprintf("Dash (%s).lnk", chain);
|
|
}
|
|
|
|
bool GetStartOnSystemStartup()
|
|
{
|
|
// check for Dash*.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));
|
|
|
|
// Start client minimized
|
|
QString strArgs = "-min";
|
|
// Set -testnet /-regtest options
|
|
strArgs += QString::fromStdString(strprintf(" -testnet=%d -regtest=%d", GetBoolArg("-testnet", false), GetBoolArg("-regtest", false)));
|
|
|
|
#ifdef UNICODE
|
|
boost::scoped_array<TCHAR> args(new TCHAR[strArgs.length() + 1]);
|
|
// Convert the QString to TCHAR*
|
|
strArgs.toWCharArray(args.get());
|
|
// Add missing '\0'-termination to string
|
|
args[strArgs.length()] = '\0';
|
|
#endif
|
|
|
|
// Set the path to the shortcut target
|
|
psl->SetPath(pszExePath);
|
|
PathRemoveFileSpec(pszExePath);
|
|
psl->SetWorkingDirectory(pszExePath);
|
|
psl->SetShowCmd(SW_SHOWMINNOACTIVE);
|
|
#ifndef UNICODE
|
|
psl->SetArguments(strArgs.toStdString().c_str());
|
|
#else
|
|
psl->SetArguments(args.get());
|
|
#endif
|
|
|
|
// 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(Q_OS_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()
|
|
{
|
|
std::string chain = ChainNameFromCommandLine();
|
|
if (chain == CBaseChainParams::MAIN)
|
|
return GetAutostartDir() / "dash.desktop";
|
|
return GetAutostartDir() / strprintf("dash-%s.lnk", chain);
|
|
}
|
|
|
|
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;
|
|
std::string chain = ChainNameFromCommandLine();
|
|
// Write a dash.desktop file to the autostart directory:
|
|
optionFile << "[Desktop Entry]\n";
|
|
optionFile << "Type=Application\n";
|
|
if (chain == CBaseChainParams::MAIN)
|
|
optionFile << "Name=Dash\n";
|
|
else
|
|
optionFile << strprintf("Name=Bitcoin (%s)\n", chain);
|
|
optionFile << "Exec=" << pszExePath << strprintf(" -min -testnet=%d -regtest=%d\n", GetBoolArg("-testnet", false), GetBoolArg("-regtest", false));
|
|
optionFile << "Terminal=false\n";
|
|
optionFile << "Hidden=false\n";
|
|
optionFile.close();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
#elif defined(Q_OS_MAC)
|
|
// based on: https://github.com/Mozketo/LaunchAtLoginController/blob/master/LaunchAtLoginController.m
|
|
|
|
#include <CoreFoundation/CoreFoundation.h>
|
|
#include <CoreServices/CoreServices.h>
|
|
|
|
LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list, CFURLRef findUrl);
|
|
LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list, CFURLRef findUrl)
|
|
{
|
|
// loop through the list of startup items and try to find the dash app
|
|
CFArrayRef listSnapshot = LSSharedFileListCopySnapshot(list, NULL);
|
|
for(int i = 0; i < CFArrayGetCount(listSnapshot); i++) {
|
|
LSSharedFileListItemRef item = (LSSharedFileListItemRef)CFArrayGetValueAtIndex(listSnapshot, i);
|
|
UInt32 resolutionFlags = kLSSharedFileListNoUserInteraction | kLSSharedFileListDoNotMountVolumes;
|
|
CFURLRef currentItemURL = NULL;
|
|
|
|
#if defined(MAC_OS_X_VERSION_MAX_ALLOWED) && MAC_OS_X_VERSION_MAX_ALLOWED >= 10100
|
|
if(&LSSharedFileListItemCopyResolvedURL)
|
|
currentItemURL = LSSharedFileListItemCopyResolvedURL(item, resolutionFlags, NULL);
|
|
#if defined(MAC_OS_X_VERSION_MIN_REQUIRED) && MAC_OS_X_VERSION_MIN_REQUIRED < 10100
|
|
else
|
|
LSSharedFileListItemResolve(item, resolutionFlags, ¤tItemURL, NULL);
|
|
#endif
|
|
#else
|
|
LSSharedFileListItemResolve(item, resolutionFlags, ¤tItemURL, NULL);
|
|
#endif
|
|
|
|
if(currentItemURL && CFEqual(currentItemURL, findUrl)) {
|
|
// found
|
|
CFRelease(currentItemURL);
|
|
return item;
|
|
}
|
|
if(currentItemURL) {
|
|
CFRelease(currentItemURL);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
bool GetStartOnSystemStartup()
|
|
{
|
|
CFURLRef bitcoinAppUrl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
|
|
LSSharedFileListRef loginItems = LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL);
|
|
LSSharedFileListItemRef foundItem = findStartupItemInList(loginItems, bitcoinAppUrl);
|
|
return !!foundItem; // return boolified object
|
|
}
|
|
|
|
bool SetStartOnSystemStartup(bool fAutoStart)
|
|
{
|
|
CFURLRef bitcoinAppUrl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
|
|
LSSharedFileListRef loginItems = LSSharedFileListCreate(NULL, kLSSharedFileListSessionLoginItems, NULL);
|
|
LSSharedFileListItemRef foundItem = findStartupItemInList(loginItems, bitcoinAppUrl);
|
|
|
|
if(fAutoStart && !foundItem) {
|
|
// add dash app to startup item list
|
|
LSSharedFileListInsertItemURL(loginItems, kLSSharedFileListItemBeforeFirst, NULL, NULL, bitcoinAppUrl, NULL, NULL);
|
|
}
|
|
else if(!fAutoStart && foundItem) {
|
|
// remove item
|
|
LSSharedFileListItemRemove(loginItems, foundItem);
|
|
}
|
|
return true;
|
|
}
|
|
#else
|
|
|
|
bool GetStartOnSystemStartup() { return false; }
|
|
bool SetStartOnSystemStartup(bool fAutoStart) { return false; }
|
|
|
|
#endif
|
|
|
|
void saveWindowGeometry(const QString& strSetting, QWidget *parent)
|
|
{
|
|
QSettings settings;
|
|
settings.setValue(strSetting + "Pos", parent->pos());
|
|
settings.setValue(strSetting + "Size", parent->size());
|
|
}
|
|
|
|
void restoreWindowGeometry(const QString& strSetting, const QSize& defaultSize, QWidget *parent)
|
|
{
|
|
QSettings settings;
|
|
QPoint pos = settings.value(strSetting + "Pos").toPoint();
|
|
QSize size = settings.value(strSetting + "Size", defaultSize).toSize();
|
|
|
|
if (!pos.x() && !pos.y()) {
|
|
QRect screen = QApplication::desktop()->screenGeometry();
|
|
pos.setX((screen.width() - size.width()) / 2);
|
|
pos.setY((screen.height() - size.height()) / 2);
|
|
}
|
|
|
|
parent->resize(size);
|
|
parent->move(pos);
|
|
}
|
|
|
|
// Return name of current UI-theme or default theme if no theme was found
|
|
QString getThemeName()
|
|
{
|
|
QSettings settings;
|
|
QString theme = settings.value("theme", "").toString();
|
|
|
|
if(!theme.isEmpty()){
|
|
return theme;
|
|
}
|
|
return QString("light");
|
|
}
|
|
|
|
// Open CSS when configured
|
|
QString loadStyleSheet()
|
|
{
|
|
QString styleSheet;
|
|
QSettings settings;
|
|
QString cssName;
|
|
QString theme = settings.value("theme", "").toString();
|
|
|
|
if(!theme.isEmpty()){
|
|
cssName = QString(":/css/") + theme;
|
|
}
|
|
else {
|
|
cssName = QString(":/css/light");
|
|
settings.setValue("theme", "light");
|
|
}
|
|
|
|
QFile qFile(cssName);
|
|
if (qFile.open(QFile::ReadOnly)) {
|
|
styleSheet = QLatin1String(qFile.readAll());
|
|
}
|
|
|
|
return styleSheet;
|
|
}
|
|
|
|
void setClipboard(const QString& str)
|
|
{
|
|
QApplication::clipboard()->setText(str, QClipboard::Clipboard);
|
|
QApplication::clipboard()->setText(str, QClipboard::Selection);
|
|
}
|
|
|
|
#if BOOST_FILESYSTEM_VERSION >= 3
|
|
boost::filesystem::path qstringToBoostPath(const QString &path)
|
|
{
|
|
return boost::filesystem::path(path.toStdString(), utf8);
|
|
}
|
|
|
|
QString boostPathToQString(const boost::filesystem::path &path)
|
|
{
|
|
return QString::fromStdString(path.string(utf8));
|
|
}
|
|
#else
|
|
#warning Conversion between boost path and QString can use invalid character encoding with boost_filesystem v2 and older
|
|
boost::filesystem::path qstringToBoostPath(const QString &path)
|
|
{
|
|
return boost::filesystem::path(path.toStdString());
|
|
}
|
|
|
|
QString boostPathToQString(const boost::filesystem::path &path)
|
|
{
|
|
return QString::fromStdString(path.string());
|
|
}
|
|
#endif
|
|
|
|
QString formatDurationStr(int secs)
|
|
{
|
|
QStringList strList;
|
|
int days = secs / 86400;
|
|
int hours = (secs % 86400) / 3600;
|
|
int mins = (secs % 3600) / 60;
|
|
int seconds = secs % 60;
|
|
|
|
if (days)
|
|
strList.append(QString(QObject::tr("%1 d")).arg(days));
|
|
if (hours)
|
|
strList.append(QString(QObject::tr("%1 h")).arg(hours));
|
|
if (mins)
|
|
strList.append(QString(QObject::tr("%1 m")).arg(mins));
|
|
if (seconds || (!days && !hours && !mins))
|
|
strList.append(QString(QObject::tr("%1 s")).arg(seconds));
|
|
|
|
return strList.join(" ");
|
|
}
|
|
|
|
QString formatServicesStr(quint64 mask)
|
|
{
|
|
QStringList strList;
|
|
|
|
// Just scan the last 8 bits for now.
|
|
for (int i = 0; i < 8; i++) {
|
|
uint64_t check = 1 << i;
|
|
if (mask & check)
|
|
{
|
|
switch (check)
|
|
{
|
|
case NODE_NETWORK:
|
|
strList.append("NETWORK");
|
|
break;
|
|
case NODE_GETUTXO:
|
|
strList.append("GETUTXO");
|
|
break;
|
|
case NODE_BLOOM:
|
|
strList.append("BLOOM");
|
|
break;
|
|
default:
|
|
strList.append(QString("%1[%2]").arg("UNKNOWN").arg(check));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (strList.size())
|
|
return strList.join(" & ");
|
|
else
|
|
return QObject::tr("None");
|
|
}
|
|
|
|
QString formatPingTime(double dPingTime)
|
|
{
|
|
return dPingTime == 0 ? QObject::tr("N/A") : QString(QObject::tr("%1 ms")).arg(QString::number((int)(dPingTime * 1000), 10));
|
|
}
|
|
|
|
QString formatTimeOffset(int64_t nTimeOffset)
|
|
{
|
|
return QString(QObject::tr("%1 s")).arg(QString::number((int)nTimeOffset, 10));
|
|
}
|
|
|
|
} // namespace GUIUtil
|