fd6da81954
Creates a wallet-specific, configurable dust limit that enables gradual implementation of the dust limit. Each transaction created with the wallet will adhere to this threshold rather than the dust limits used for relay, so that the wallet stays usable while the network changes (lowers) its dust limits. This change only implements the parameter but does not change its default value.
1056 lines
33 KiB
C++
1056 lines
33 KiB
C++
// Copyright (c) 2011-2016 The Bitcoin Core developers
|
|
// Copyright (c) 2021 The Dogecoin 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 "policy/policy.h"
|
|
#include "protocol.h"
|
|
#include "script/script.h"
|
|
#include "script/standard.h"
|
|
#include "util.h"
|
|
|
|
#ifdef ENABLE_WALLET
|
|
#include "wallet/wallet.h"
|
|
#endif
|
|
|
|
#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>
|
|
#include <QMouseEvent>
|
|
|
|
#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
|
|
#include <QProcess>
|
|
|
|
void ForceActivation();
|
|
#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()
|
|
{
|
|
QFont font("Cursive");
|
|
font.setFamily("Comic Sans MS");
|
|
return font;
|
|
}
|
|
|
|
// Just some dummy data to generate an convincing random-looking (but consistent) address
|
|
static const uint8_t dummydata[] = {0xeb,0x15,0x23,0x1d,0xfc,0xeb,0x60,0x92,0x58,0x86,0xb6,0x7d,0x06,0x52,0x99,0x92,0x59,0x15,0xae,0xb1,0x72,0xc0,0x66,0x47};
|
|
|
|
// Generate a dummy address with invalid CRC, starting with the network prefix.
|
|
static std::string DummyAddress(const CChainParams ¶ms)
|
|
{
|
|
std::vector<unsigned char> sourcedata = params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
|
|
sourcedata.insert(sourcedata.end(), dummydata, dummydata + sizeof(dummydata));
|
|
for(int i=0; i<256; ++i) { // Try every trailing byte
|
|
std::string s = EncodeBase58(sourcedata.data(), sourcedata.data() + sourcedata.size());
|
|
if (!CBitcoinAddress(s).IsValid())
|
|
return s;
|
|
sourcedata[sourcedata.size()-1] += 1;
|
|
}
|
|
return "";
|
|
}
|
|
|
|
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 Dogecoin address (e.g. %1)").arg(
|
|
QString::fromStdString(DummyAddress(Params()))));
|
|
#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 dogecoin: URI
|
|
if(!uri.isValid() || uri.scheme() != QString("dogecoin"))
|
|
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::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 dogecoin:// to dogecoin:
|
|
//
|
|
// Cannot handle this later, because dogecoin:// will cause Qt to see the part after // as host,
|
|
// which will lower-case it (and thus invalidate the address).
|
|
if(uri.startsWith("dogecoin://", Qt::CaseInsensitive))
|
|
{
|
|
uri.replace(0, 11, "dogecoin:");
|
|
}
|
|
QUrl uriInstance(uri);
|
|
return parseBitcoinURI(uriInstance, out);
|
|
}
|
|
|
|
QString formatBitcoinURI(const SendCoinsRecipient &info)
|
|
{
|
|
QString ret = QString("dogecoin:%1").arg(info.address);
|
|
int paramCount = 0;
|
|
|
|
if (info.amount)
|
|
{
|
|
ret += QString("?amount=%1").arg(BitcoinUnits::format(BitcoinUnits::BTC, 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;
|
|
}
|
|
|
|
#ifdef ENABLE_WALLET
|
|
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(CWallet::discardThreshold);
|
|
}
|
|
#endif
|
|
|
|
QString HtmlEscape(const QString& str, bool fMultiLine)
|
|
{
|
|
#if QT_VERSION < 0x050000
|
|
QString escaped = Qt::escape(str);
|
|
#else
|
|
QString escaped = str.toHtmlEscaped();
|
|
#endif
|
|
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());
|
|
}
|
|
}
|
|
|
|
QList<QModelIndex> getEntryData(QAbstractItemView *view, int column)
|
|
{
|
|
if(!view || !view->selectionModel())
|
|
return QList<QModelIndex>();
|
|
return view->selectionModel()->selectedRows(column);
|
|
}
|
|
|
|
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 bringToFront(QWidget* w)
|
|
{
|
|
#ifdef Q_OS_MAC
|
|
ForceActivation();
|
|
#endif
|
|
if (w) {
|
|
// activateWindow() (sometimes) helps with keyboard focus on Windows
|
|
if (w->isMinimized()) {
|
|
w->showNormal();
|
|
} else {
|
|
w->show();
|
|
}
|
|
w->activateWindow();
|
|
w->raise();
|
|
}
|
|
}
|
|
|
|
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 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") && !Qt::mightBeRichText(tooltip))
|
|
{
|
|
// Envelop with <qt></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) + "</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 table's 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 table's 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, QObject *parent) :
|
|
QObject(parent),
|
|
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) / "Dogecoin.lnk";
|
|
if (chain == CBaseChainParams::TESTNET) // Remove this special case when CBaseChainParams::TESTNET = "testnet4"
|
|
return GetSpecialFolderPath(CSIDL_STARTUP) / "Dogecoin (testnet).lnk";
|
|
return GetSpecialFolderPath(CSIDL_STARTUP) / strprintf("Dogecoin (%s).lnk", chain);
|
|
}
|
|
|
|
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));
|
|
|
|
// 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() / "bitcoin.desktop";
|
|
return GetAutostartDir() / strprintf("bitcoin-%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 bitcoin.desktop file to the autostart directory:
|
|
optionFile << "[Desktop Entry]\n";
|
|
optionFile << "Type=Application\n";
|
|
if (chain == CBaseChainParams::MAIN)
|
|
optionFile << "Name=Dogecoin\n";
|
|
else
|
|
optionFile << strprintf("Name=Dogecoin (%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)
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
|
|
// 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 bitcoin 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 bitcoin app to startup item list
|
|
LSSharedFileListInsertItemURL(loginItems, kLSSharedFileListItemBeforeFirst, NULL, NULL, bitcoinAppUrl, NULL, NULL);
|
|
}
|
|
else if(!fAutoStart && foundItem) {
|
|
// remove item
|
|
LSSharedFileListItemRemove(loginItems, foundItem);
|
|
}
|
|
return true;
|
|
}
|
|
#pragma GCC diagnostic pop
|
|
#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);
|
|
}
|
|
|
|
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;
|
|
case NODE_WITNESS:
|
|
strList.append("WITNESS");
|
|
break;
|
|
case NODE_XTHIN:
|
|
strList.append("XTHIN");
|
|
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 == std::numeric_limits<int64_t>::max()/1e6 || dPingTime == 0) ? QObject::tr("N/A") : QString(QObject::tr("%1 ms")).arg(QString::number((int)(dPingTime * 1000), 10));
|
|
}
|
|
|
|
QString formatDataSizeValue(uint64_t uValue)
|
|
{
|
|
// Why handle these comparisons directly, instead of a clever algorithm?
|
|
// This is likely to be called in a tight loop, so avoid the overhead of
|
|
// setting up a constant list and walking an iterator.
|
|
static const uint64_t TERABYTE_SIZE = UINT64_C(1024*1024*1024*1024);
|
|
static const uint64_t GIGABYTE_SIZE = UINT64_C(1024*1024*1024);
|
|
static const uint64_t MEGABYTE_SIZE = UINT64_C(1024*1024);
|
|
static const uint64_t KILOBYTE_SIZE = UINT64_C(1024);
|
|
|
|
QString unitFormat = QObject::tr("%1 B");
|
|
|
|
if (uValue == std::numeric_limits<int64_t>::max()/1e6 || uValue == 0)
|
|
return QObject::tr("N/A");
|
|
|
|
if (uValue > TERABYTE_SIZE) {
|
|
unitFormat = QObject::tr("%1 TB");
|
|
uValue /= TERABYTE_SIZE;
|
|
} else if (uValue > GIGABYTE_SIZE) {
|
|
unitFormat = QObject::tr("%1 GB");
|
|
uValue /= GIGABYTE_SIZE;
|
|
} else if (uValue > MEGABYTE_SIZE) {
|
|
unitFormat = QObject::tr("%1 MB");
|
|
uValue /= MEGABYTE_SIZE;
|
|
} else if (uValue > KILOBYTE_SIZE) {
|
|
unitFormat = QObject::tr("%1 KB");
|
|
uValue /= KILOBYTE_SIZE;
|
|
}
|
|
|
|
return QString(unitFormat).arg(QString::number(uValue), 10);
|
|
}
|
|
|
|
QString formatTimeOffset(int64_t nTimeOffset)
|
|
{
|
|
return QString(QObject::tr("%1 s")).arg(QString::number((int)nTimeOffset, 10));
|
|
}
|
|
|
|
QString formatNiceTimeOffset(qint64 secs)
|
|
{
|
|
// Represent time from last generated block in human readable text
|
|
QString timeBehindText;
|
|
const int HOUR_IN_SECONDS = 60*60;
|
|
const int DAY_IN_SECONDS = 24*60*60;
|
|
const int WEEK_IN_SECONDS = 7*24*60*60;
|
|
const int YEAR_IN_SECONDS = 31556952; // Average length of year in Gregorian calendar
|
|
if(secs < 60)
|
|
{
|
|
timeBehindText = QObject::tr("%n second(s)","",secs);
|
|
}
|
|
else if(secs < 2*HOUR_IN_SECONDS)
|
|
{
|
|
timeBehindText = QObject::tr("%n minute(s)","",secs/60);
|
|
}
|
|
else if(secs < 2*DAY_IN_SECONDS)
|
|
{
|
|
timeBehindText = QObject::tr("%n hour(s)","",secs/HOUR_IN_SECONDS);
|
|
}
|
|
else if(secs < 2*WEEK_IN_SECONDS)
|
|
{
|
|
timeBehindText = QObject::tr("%n day(s)","",secs/DAY_IN_SECONDS);
|
|
}
|
|
else if(secs < YEAR_IN_SECONDS)
|
|
{
|
|
timeBehindText = QObject::tr("%n week(s)","",secs/WEEK_IN_SECONDS);
|
|
}
|
|
else
|
|
{
|
|
qint64 years = secs / YEAR_IN_SECONDS;
|
|
qint64 remainder = secs % YEAR_IN_SECONDS;
|
|
timeBehindText = QObject::tr("%1 and %2").arg(QObject::tr("%n year(s)", "", years)).arg(QObject::tr("%n week(s)","", remainder/WEEK_IN_SECONDS));
|
|
}
|
|
return timeBehindText;
|
|
}
|
|
|
|
void ClickableLabel::mouseReleaseEvent(QMouseEvent *event)
|
|
{
|
|
Q_EMIT clicked(event->pos());
|
|
}
|
|
|
|
void ClickableProgressBar::mouseReleaseEvent(QMouseEvent *event)
|
|
{
|
|
Q_EMIT clicked(event->pos());
|
|
}
|
|
|
|
} // namespace GUIUtil
|