2020-10-14 20:12:32 +00:00
|
|
|
// SPDX-License-Identifier: BSD-3-Clause
|
2020-12-26 19:56:06 +00:00
|
|
|
// Copyright (c) 2020-2021, The Monero Project.
|
2020-10-14 20:12:32 +00:00
|
|
|
|
|
|
|
#include <QStandardItemModel>
|
|
|
|
#include <QTableWidget>
|
|
|
|
#include <QMessageBox>
|
|
|
|
#include <QDesktopServices>
|
|
|
|
#include <QScrollBar>
|
|
|
|
#include <QFileDialog>
|
|
|
|
|
|
|
|
#include "xmrigwidget.h"
|
|
|
|
#include "ui_xmrigwidget.h"
|
|
|
|
|
2020-10-16 19:01:18 +00:00
|
|
|
XMRigWidget::XMRigWidget(AppContext *ctx, QWidget *parent) :
|
2020-10-14 20:12:32 +00:00
|
|
|
QWidget(parent),
|
|
|
|
ui(new Ui::XMRigWidget),
|
2020-10-16 19:01:18 +00:00
|
|
|
m_ctx(ctx),
|
2022-03-15 18:49:58 +00:00
|
|
|
m_modelRig(new QStandardItemModel(this)),
|
|
|
|
m_modelWownerod(new QStandardItemModel(this)),
|
|
|
|
m_contextMenuRig(new QMenu(this)),
|
|
|
|
m_contextMenuWownerod(new QMenu(this))
|
2020-10-14 20:12:32 +00:00
|
|
|
{
|
|
|
|
ui->setupUi(this);
|
2022-03-21 17:12:11 +00:00
|
|
|
this->resetUI();
|
2020-10-14 20:12:32 +00:00
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
QPixmap p(":assets/images/fire.png");
|
|
|
|
ui->lbl_logo->setPixmap(p.scaled(268, 271, Qt::KeepAspectRatio, Qt::SmoothTransformation));
|
2020-10-14 20:12:32 +00:00
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
// table XMRig
|
|
|
|
ui->tableRig->setModel(this->m_modelRig);
|
|
|
|
m_contextMenuRig->addAction(QIcon(":/assets/images/network.png"), "Download file", this, &XMRigWidget::rigLinkClicked);
|
|
|
|
connect(ui->tableRig, &QHeaderView::customContextMenuRequested, this, &XMRigWidget::showContextRigMenu);
|
|
|
|
connect(ui->tableRig, &QTableView::doubleClicked, this, &XMRigWidget::rigLinkClicked);
|
|
|
|
|
|
|
|
// table wownerod
|
|
|
|
ui->tableWownerod->setModel(this->m_modelWownerod);
|
|
|
|
m_contextMenuWownerod->addAction(QIcon(":/assets/images/network.png"), "Download file", this, &XMRigWidget::wownerodLinkClicked);
|
|
|
|
connect(ui->tableWownerod, &QHeaderView::customContextMenuRequested, this, &XMRigWidget::showContextWownerodMenu);
|
|
|
|
connect(ui->tableWownerod, &QTableView::doubleClicked, this, &XMRigWidget::wownerodLinkClicked);
|
2020-10-14 20:12:32 +00:00
|
|
|
|
|
|
|
// threads
|
|
|
|
ui->threadSlider->setMinimum(1);
|
|
|
|
int threads = QThread::idealThreadCount();
|
2020-12-11 13:36:08 +00:00
|
|
|
m_threads = threads / 2;
|
2020-10-14 20:12:32 +00:00
|
|
|
ui->threadSlider->setMaximum(threads);
|
|
|
|
ui->threadSlider->setValue(m_threads);
|
|
|
|
ui->label_threads->setText(QString("CPU threads: %1").arg(m_threads));
|
|
|
|
connect(ui->threadSlider, &QSlider::valueChanged, this, &XMRigWidget::onThreadsValueChanged);
|
|
|
|
|
|
|
|
// buttons
|
|
|
|
connect(ui->btn_start, &QPushButton::clicked, this, &XMRigWidget::onStartClicked);
|
|
|
|
connect(ui->btn_stop, &QPushButton::clicked, this, &XMRigWidget::onStopClicked);
|
|
|
|
connect(ui->btn_browse, &QPushButton::clicked, this, &XMRigWidget::onBrowseClicked);
|
|
|
|
connect(ui->btn_clear, &QPushButton::clicked, this, &XMRigWidget::onClearClicked);
|
|
|
|
|
2022-03-21 17:12:11 +00:00
|
|
|
// graphics
|
|
|
|
bool simplifiedUI = config()->get(Config::simplifiedMiningInterface).toBool();
|
|
|
|
ui->comboBox_gfx->setCurrentIndex(simplifiedUI ? 1 : 0);
|
|
|
|
connect(ui->comboBox_gfx, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &XMRigWidget::onSimplifiedMiningChanged);
|
2020-10-16 19:01:18 +00:00
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
// wownerod binary
|
|
|
|
auto path = config()->get(Config::wownerodPath).toString();
|
|
|
|
if(!path.isEmpty())
|
2020-10-17 21:14:56 +00:00
|
|
|
ui->lineEdit_path->setText(path);
|
2020-10-14 20:12:32 +00:00
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
connect(ui->lineEdit_path, &QLineEdit::textChanged, [=] {
|
|
|
|
config()->set(Config::wownerodPath, ui->lineEdit_path->text().trimmed());
|
|
|
|
});
|
2020-10-14 20:12:32 +00:00
|
|
|
|
|
|
|
// info
|
2022-03-15 18:49:58 +00:00
|
|
|
this->appendText(QString("Detected %1 CPU threads.").arg(threads));
|
|
|
|
if(path.isEmpty())
|
|
|
|
this->appendText(QString("wownerod path is empty - please point towards the wownerod executable.").arg(path));
|
|
|
|
else if(!Utils::fileExists(path))
|
|
|
|
this->appendText("Invalid path to the wownerod executable detected. Please set the correct path.");
|
|
|
|
else {
|
|
|
|
this->appendText(QString("wownerod path set to '%1'").arg(path));
|
|
|
|
this->appendText("Ready to mine.");
|
|
|
|
}
|
|
|
|
}
|
2020-10-17 21:14:56 +00:00
|
|
|
|
2022-03-21 17:12:11 +00:00
|
|
|
void XMRigWidget::resetUI() {
|
|
|
|
ui->consoleFrame->hide();
|
|
|
|
ui->qmlFrame->hide();
|
|
|
|
ui->qmlFrameTxt->hide();
|
|
|
|
|
|
|
|
ui->check_autoscroll->setChecked(true);
|
|
|
|
ui->label_status->setTextInteractionFlags(Qt::TextSelectableByMouse);
|
|
|
|
ui->label_status->hide();
|
|
|
|
ui->console->clear();
|
|
|
|
|
|
|
|
this->destroyQml();
|
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::startUI() {
|
|
|
|
this->resetUI();
|
|
|
|
bool simplifiedUI = config()->get(Config::simplifiedMiningInterface).toBool();
|
|
|
|
|
|
|
|
if(simplifiedUI) {
|
|
|
|
this->initConsole();
|
|
|
|
} else {
|
|
|
|
this->initQML();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::initConsole() {
|
|
|
|
ui->consoleFrame->show();
|
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::initQML() {
|
|
|
|
if(m_quickWidget != nullptr) return;
|
|
|
|
m_quickWidget = new QQuickWidget(this);
|
|
|
|
|
|
|
|
auto *qctx = m_quickWidget->rootContext();
|
|
|
|
qctx->setContextProperty("cfg", config());
|
|
|
|
qctx->setContextProperty("ctx", m_ctx);
|
|
|
|
qctx->setContextProperty("mining", this);
|
|
|
|
|
|
|
|
m_quickWidget->setSource(QUrl("qrc:/mining.qml"));
|
|
|
|
m_quickWidget->setResizeMode(QQuickWidget::SizeRootObjectToView);
|
|
|
|
|
|
|
|
connect((QObject*)m_quickWidget->rootObject(), SIGNAL(startMining()),
|
|
|
|
this, SLOT(onStartClicked()));
|
|
|
|
|
|
|
|
connect((QObject*)m_quickWidget->rootObject(), SIGNAL(stopMining()),
|
|
|
|
this, SLOT(onStopClicked()));
|
|
|
|
|
|
|
|
ui->qmlFrame->layout()->addWidget(m_quickWidget);
|
|
|
|
ui->qmlFrame->show();
|
|
|
|
qDebug() << "created QML mining widget";
|
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::destroyQml() {
|
|
|
|
if(m_quickWidget == nullptr) return;
|
|
|
|
m_quickWidget->disconnect();
|
|
|
|
m_quickWidget->deleteLater();
|
|
|
|
m_quickWidget = nullptr;
|
|
|
|
qDebug() << "destroyed QML mining widget";
|
|
|
|
}
|
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
void XMRigWidget::appendText(const QString &line) {
|
|
|
|
ui->console->appendPlainText(line);
|
|
|
|
m_consoleBuffer += 1;
|
|
|
|
if(m_consoleBuffer >= m_consoleBufferMax) {
|
|
|
|
ui->console->clear();
|
|
|
|
m_consoleBuffer = 0;
|
|
|
|
}
|
2020-10-16 19:01:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::onWalletClosed() {
|
|
|
|
this->onStopClicked();
|
|
|
|
this->onClearClicked();
|
|
|
|
}
|
|
|
|
|
2021-03-27 18:59:21 +00:00
|
|
|
void XMRigWidget::onWalletOpened(Wallet *wallet){
|
2022-03-15 18:49:58 +00:00
|
|
|
int egiwoge = 1;
|
2020-10-14 20:12:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::onThreadsValueChanged(int threads) {
|
2020-12-11 13:36:08 +00:00
|
|
|
m_threads = threads;
|
2020-10-14 20:12:32 +00:00
|
|
|
ui->label_threads->setText(QString("CPU threads: %1").arg(m_threads));
|
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::onBrowseClicked() {
|
|
|
|
QString fileName = QFileDialog::getOpenFileName(
|
2022-03-15 18:49:58 +00:00
|
|
|
this, "Path to wownerod executable", QDir::homePath());
|
2020-10-14 20:12:32 +00:00
|
|
|
if (fileName.isEmpty()) return;
|
2022-03-15 18:49:58 +00:00
|
|
|
config()->set(Config::wownerodPath, fileName);
|
2020-10-14 20:12:32 +00:00
|
|
|
ui->lineEdit_path->setText(fileName);
|
|
|
|
}
|
|
|
|
|
2022-03-21 17:12:11 +00:00
|
|
|
void XMRigWidget::onSyncStatus(unsigned int from, unsigned int to, unsigned int pct) {
|
|
|
|
emit syncStatus(from, to, pct);
|
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::onDaemonStateChanged(DaemonMiningState state) {
|
|
|
|
if(state == DaemonMiningState::idle) {
|
|
|
|
ui->btn_stop->setEnabled(false);
|
|
|
|
ui->btn_start->setEnabled(true);
|
|
|
|
ui->label_status->hide();
|
|
|
|
} else {
|
|
|
|
ui->btn_stop->setEnabled(true);
|
|
|
|
ui->btn_start->setEnabled(false);
|
|
|
|
ui->label_status->show();
|
|
|
|
}
|
|
|
|
|
|
|
|
m_daemonMiningState = state;
|
|
|
|
emit daemonMiningStateChanged();
|
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::onUptimeChanged(const QString &uptime) {
|
|
|
|
emit uptimeChanged(uptime);
|
|
|
|
}
|
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
void XMRigWidget::onBlockReward() {
|
|
|
|
QDateTime date = QDateTime::currentDateTime();
|
|
|
|
QString formattedTime = date.toString("yyyy/MM/dd hh:mm");
|
2022-03-21 17:12:11 +00:00
|
|
|
|
|
|
|
auto reward = QString("Congrats: new block found at %1").arg(formattedTime);
|
|
|
|
|
|
|
|
// @TODO: this might be blocking, what if multiple rewards happen?
|
|
|
|
QMessageBox::information(this, "Reward found", reward);
|
2022-03-15 18:49:58 +00:00
|
|
|
}
|
|
|
|
|
2020-10-14 20:12:32 +00:00
|
|
|
void XMRigWidget::onClearClicked() {
|
|
|
|
ui->console->clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::onStartClicked() {
|
2022-03-15 18:49:58 +00:00
|
|
|
auto binPath = config()->get(Config::wownerodPath).toString();
|
|
|
|
if(!m_ctx->XMRig->start(binPath, m_threads)) return;
|
2020-12-21 20:34:36 +00:00
|
|
|
|
2020-10-14 20:12:32 +00:00
|
|
|
ui->btn_start->setEnabled(false);
|
|
|
|
ui->btn_stop->setEnabled(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::onStopClicked() {
|
2022-03-21 17:12:11 +00:00
|
|
|
if(m_ctx->XMRig->daemonMiningState != DaemonMiningState::idle)
|
|
|
|
m_ctx->XMRig->stop();
|
2020-10-14 20:12:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::onProcessOutput(const QByteArray &data) {
|
2022-03-21 17:12:11 +00:00
|
|
|
auto line = Utils::barrayToString(data);
|
|
|
|
line = line.trimmed();
|
|
|
|
this->appendText(line);
|
2020-10-14 20:12:32 +00:00
|
|
|
|
|
|
|
if(ui->check_autoscroll->isChecked())
|
|
|
|
ui->console->verticalScrollBar()->setValue(ui->console->verticalScrollBar()->maximum());
|
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::onProcessError(const QString &msg) {
|
2022-03-15 18:49:58 +00:00
|
|
|
this->appendText(msg);
|
2020-10-14 20:12:32 +00:00
|
|
|
}
|
|
|
|
|
2022-03-21 17:12:11 +00:00
|
|
|
void XMRigWidget::onSimplifiedMiningChanged(int idx) {
|
|
|
|
config()->set(Config::simplifiedMiningInterface, idx == 1);
|
|
|
|
this->startUI();
|
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::onHashrate(const QString &rate) {
|
2020-10-14 20:12:32 +00:00
|
|
|
ui->label_status->show();
|
2022-03-21 17:12:11 +00:00
|
|
|
ui->label_status->setText(QString("Mining at %1").arg(rate));
|
|
|
|
emit hashrate(rate);
|
2020-10-14 20:12:32 +00:00
|
|
|
}
|
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
void XMRigWidget::onWownerodDownloads(const QJsonObject &data) {
|
|
|
|
m_modelWownerod->clear();
|
|
|
|
m_urlsWownerod.clear();
|
|
|
|
|
|
|
|
auto version = data.value("version").toString();
|
|
|
|
ui->label_latest_version_wownerod->setText(QString("Latest version: %1").arg(version));
|
|
|
|
QJsonObject assets = data.value("assets").toObject();
|
|
|
|
|
|
|
|
const auto _linux = assets.value("linux").toArray();
|
|
|
|
const auto macos = assets.value("macos").toArray();
|
|
|
|
const auto windows = assets.value("windows").toArray();
|
2020-10-14 20:12:32 +00:00
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
auto info = QSysInfo::productType();
|
|
|
|
QJsonArray *os_assets;
|
|
|
|
if(info == "osx") {
|
|
|
|
os_assets = const_cast<QJsonArray *>(&macos);
|
|
|
|
} else if (info == "windows") {
|
|
|
|
os_assets = const_cast<QJsonArray *>(&windows);
|
|
|
|
} else {
|
|
|
|
// assume linux
|
|
|
|
os_assets = const_cast<QJsonArray *>(&_linux);
|
|
|
|
}
|
|
|
|
|
|
|
|
int i = 0;
|
|
|
|
for(const auto &entry: *os_assets) {
|
|
|
|
auto _obj = entry.toObject();
|
|
|
|
auto _name = _obj.value("name").toString();
|
|
|
|
auto _url = _obj.value("url").toString();
|
|
|
|
auto _created_at = _obj.value("created_at").toString();
|
|
|
|
|
|
|
|
m_urlsWownerod.append(_url);
|
|
|
|
auto download_count = _obj.value("download_count").toInt();
|
|
|
|
|
|
|
|
m_modelWownerod->setItem(i, 0, Utils::qStandardItem(_name));
|
|
|
|
m_modelWownerod->setItem(i, 1, Utils::qStandardItem(_created_at));
|
|
|
|
m_modelWownerod->setItem(i, 2, Utils::qStandardItem(QString::number(download_count)));
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_modelWownerod->setHeaderData(0, Qt::Horizontal, tr("Filename"), Qt::DisplayRole);
|
|
|
|
m_modelWownerod->setHeaderData(1, Qt::Horizontal, tr("Date"), Qt::DisplayRole);
|
|
|
|
m_modelWownerod->setHeaderData(2, Qt::Horizontal, tr("Downloads"), Qt::DisplayRole);
|
|
|
|
|
|
|
|
ui->tableWownerod->verticalHeader()->setVisible(false);
|
|
|
|
ui->tableWownerod->setSelectionBehavior(QAbstractItemView::SelectRows);
|
|
|
|
ui->tableWownerod->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
|
|
|
|
ui->tableWownerod->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
|
|
|
|
ui->tableWownerod->setColumnWidth(2, 100);
|
|
|
|
}
|
|
|
|
|
2022-03-21 17:12:11 +00:00
|
|
|
void XMRigWidget::onMenuTabChanged(int index) {
|
|
|
|
if(m_tabIndex == globals::Tabs::XMRIG && index != m_tabIndex)
|
|
|
|
this->resetUI();
|
|
|
|
else if(globals::Tabs(index + 1) == globals::Tabs::XMRIG)
|
|
|
|
this->startUI();
|
|
|
|
m_tabIndex = index + 1;
|
|
|
|
}
|
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
void XMRigWidget::onRigDownloads(const QJsonObject &data) {
|
|
|
|
m_modelRig->clear();
|
|
|
|
m_urlsRig.clear();
|
2020-10-14 20:12:32 +00:00
|
|
|
|
|
|
|
auto version = data.value("version").toString();
|
2022-03-15 18:49:58 +00:00
|
|
|
ui->label_latest_version_rig->setText(QString("Latest version: %1").arg(version));
|
2020-10-14 20:12:32 +00:00
|
|
|
QJsonObject assets = data.value("assets").toObject();
|
|
|
|
|
|
|
|
const auto _linux = assets.value("linux").toArray();
|
|
|
|
const auto macos = assets.value("macos").toArray();
|
|
|
|
const auto windows = assets.value("windows").toArray();
|
|
|
|
|
|
|
|
auto info = QSysInfo::productType();
|
|
|
|
QJsonArray *os_assets;
|
|
|
|
if(info == "osx") {
|
|
|
|
os_assets = const_cast<QJsonArray *>(&macos);
|
|
|
|
} else if (info == "windows") {
|
|
|
|
os_assets = const_cast<QJsonArray *>(&windows);
|
|
|
|
} else {
|
|
|
|
// assume linux
|
|
|
|
os_assets = const_cast<QJsonArray *>(&_linux);
|
|
|
|
}
|
|
|
|
|
2020-12-11 13:36:08 +00:00
|
|
|
int i = 0;
|
2020-10-14 20:12:32 +00:00
|
|
|
for(const auto &entry: *os_assets) {
|
|
|
|
auto _obj = entry.toObject();
|
|
|
|
auto _name = _obj.value("name").toString();
|
|
|
|
auto _url = _obj.value("url").toString();
|
|
|
|
auto _created_at = _obj.value("created_at").toString();
|
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
m_urlsRig.append(_url);
|
2020-10-14 20:12:32 +00:00
|
|
|
auto download_count = _obj.value("download_count").toInt();
|
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
m_modelRig->setItem(i, 0, Utils::qStandardItem(_name));
|
|
|
|
m_modelRig->setItem(i, 1, Utils::qStandardItem(_created_at));
|
|
|
|
m_modelRig->setItem(i, 2, Utils::qStandardItem(QString::number(download_count)));
|
2020-10-14 20:12:32 +00:00
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
m_modelRig->setHeaderData(0, Qt::Horizontal, tr("Filename"), Qt::DisplayRole);
|
|
|
|
m_modelRig->setHeaderData(1, Qt::Horizontal, tr("Date"), Qt::DisplayRole);
|
|
|
|
m_modelRig->setHeaderData(2, Qt::Horizontal, tr("Downloads"), Qt::DisplayRole);
|
2020-10-14 20:12:32 +00:00
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
ui->tableRig->verticalHeader()->setVisible(false);
|
|
|
|
ui->tableRig->setSelectionBehavior(QAbstractItemView::SelectRows);
|
|
|
|
ui->tableRig->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
|
|
|
|
ui->tableRig->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
|
|
|
|
ui->tableRig->setColumnWidth(2, 100);
|
2020-10-14 20:12:32 +00:00
|
|
|
}
|
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
void XMRigWidget::showContextRigMenu(const QPoint &pos) {
|
|
|
|
QModelIndex index = ui->tableRig->indexAt(pos);
|
|
|
|
if (!index.isValid())
|
2020-10-14 20:12:32 +00:00
|
|
|
return;
|
2022-03-15 18:49:58 +00:00
|
|
|
m_contextMenuRig->exec(ui->tableRig->viewport()->mapToGlobal(pos));
|
2020-10-14 20:12:32 +00:00
|
|
|
}
|
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
void XMRigWidget::showContextWownerodMenu(const QPoint &pos) {
|
|
|
|
QModelIndex index = ui->tableWownerod->indexAt(pos);
|
|
|
|
if (!index.isValid())
|
|
|
|
return;
|
|
|
|
m_contextMenuRig->exec(ui->tableWownerod->viewport()->mapToGlobal(pos));
|
|
|
|
}
|
|
|
|
|
|
|
|
void XMRigWidget::wownerodLinkClicked() {
|
|
|
|
QModelIndex index = ui->tableRig->currentIndex();
|
|
|
|
auto download_link = m_urlsRig.at(index.row());
|
|
|
|
Utils::externalLinkWarning(this, download_link);
|
2020-10-17 21:14:56 +00:00
|
|
|
}
|
|
|
|
|
2022-03-15 18:49:58 +00:00
|
|
|
void XMRigWidget::rigLinkClicked() {
|
|
|
|
QModelIndex index = ui->tableRig->currentIndex();
|
|
|
|
auto download_link = m_urlsRig.at(index.row());
|
2020-12-14 02:20:05 +00:00
|
|
|
Utils::externalLinkWarning(this, download_link);
|
2020-10-14 20:12:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QStandardItemModel *XMRigWidget::model() {
|
2022-03-15 18:49:58 +00:00
|
|
|
return m_modelRig;
|
2020-10-14 20:12:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
XMRigWidget::~XMRigWidget() {
|
|
|
|
delete ui;
|
|
|
|
}
|