ddaef95da7
Re-submitting this pull request with a single commit. This patch introduces a GUIUtil class that is used when setting up the 2 tables we have so far on the Qt-GUI. In the past you could only resize the last column, which has BTC amounts from the right border of the column header, something that was rather unnatural. If a new table were ever to be added to the interface, fixing the last columns resizing behavior is rather simple. Just look at how we initialize here a TableViewLastColumnResizingFixer object when setting up the table header's behavior, and then how we override the resize event of the component (can be the table, or the dialog) and we invoke columnResizingFixer->stretchColumnWidth(columnIndex);
757 lines
23 KiB
C++
757 lines
23 KiB
C++
// Copyright (c) 2011-2013 The Bitcoin developers
|
|
// Distributed under the MIT/X11 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 "core.h"
|
|
#include "init.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 <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 BOOST_FILESYSTEM_VERSION >= 3
|
|
static boost::filesystem::detail::utf8_codecvt_facet utf8;
|
|
#endif
|
|
|
|
namespace GUIUtil {
|
|
|
|
QString dateTimeStr(const QDateTime &date)
|
|
{
|
|
return date.date().toString(Qt::DefaultLocaleShortDate) + QString(" ") + date.toString("hh:mm");
|
|
}
|
|
|
|
QString dateTimeStr(qint64 nTime)
|
|
{
|
|
return dateTimeStr(QDateTime::fromTime_t((qint32)nTime));
|
|
}
|
|
|
|
QFont bitcoinAddressFont()
|
|
{
|
|
QFont font("Cursive");
|
|
font.setFamily("Comic Sans MS");
|
|
return font;
|
|
}
|
|
|
|
void setupAddressWidget(QValidatedLineEdit *widget, QWidget *parent)
|
|
{
|
|
parent->setFocusProxy(widget);
|
|
|
|
widget->setFont(bitcoinAddressFont());
|
|
#if QT_VERSION >= 0x040700
|
|
widget->setPlaceholderText(QObject::tr("Enter a Dogecoin address (e.g. DJ7zB7c5BsB9UJLy1rKQtY7c6CQfGiaRLM)"));
|
|
#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();
|
|
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())
|
|
{
|
|
// Parse amount in C locale with no number separators
|
|
QLocale locale(QLocale::c());
|
|
locale.setNumberOptions(QLocale::OmitGroupSeparator | QLocale::RejectGroupSeparator);
|
|
if(!BitcoinUnits::parse(BitcoinUnits::DOGE, i->second, &rv.amount, locale))
|
|
{
|
|
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)
|
|
{
|
|
QLocale localeC(QLocale::c());
|
|
localeC.setNumberOptions(QLocale::OmitGroupSeparator | QLocale::RejectGroupSeparator);
|
|
ret += QString("?amount=%1").arg(BitcoinUnits::format(BitcoinUnits::DOGE, info.amount, false, true, localeC));
|
|
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, qint64 amount)
|
|
{
|
|
CTxDestination dest = CBitcoinAddress(address.toStdString()).Get();
|
|
CScript script; script.SetDestination(dest);
|
|
CTxOut txOut(amount, script);
|
|
return txOut.IsDust(CTransaction::nMinRelayTxFee);
|
|
}
|
|
|
|
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());
|
|
}
|
|
}
|
|
|
|
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)));
|
|
}
|
|
|
|
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's 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) :
|
|
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()
|
|
{
|
|
return GetSpecialFolderPath(CSIDL_STARTUP) / "Dogecoin.lnk";
|
|
}
|
|
|
|
bool GetStartOnSystemStartup()
|
|
{
|
|
// check for Dogecoin.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() / "dogecoin.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=Dogecoin\n";
|
|
optionFile << "Exec=" << pszExePath << " -min\n";
|
|
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 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;
|
|
LSSharedFileListItemResolve(item, resolutionFlags, ¤tItemURL, NULL);
|
|
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;
|
|
}
|
|
#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
|
|
|
|
} // namespace GUIUtil
|