579 lines
21 KiB
C++
579 lines
21 KiB
C++
#include "xsteam_ui.h"
|
|
xsteam_ui::xsteam_ui(QWidget *parent) : QWidget(parent),
|
|
main_layout(new QVBoxLayout),
|
|
info_layout(new QHBoxLayout),
|
|
mind_layout(new QVBoxLayout),
|
|
foot_layout(new QHBoxLayout)
|
|
{
|
|
xsteam_init_info_layout();
|
|
xsteam_init_mind_layout();
|
|
xsteam_init_foot_layout();
|
|
xsteam_init_style();
|
|
xsteam_init_main_layout();
|
|
xsteam_init_connect();
|
|
slots_disable_enable_function(false);
|
|
QFuture<void> future = QtConcurrent::run([=]()
|
|
{
|
|
bool steam_ok=false;
|
|
bool steamtools_ok=false;
|
|
emit signals_src_combobox_update();
|
|
slots_disable_enable_function(true);
|
|
table_load_ui_data();
|
|
if(!xsteam_steam_steamtools_exists(steam_ok,steamtools_ok)){
|
|
slots_msg_text("请检查steam和steamtools路径");
|
|
btn_run_steam->setEnabled(steam_ok);
|
|
btn_run_steamtools->setEnabled(steamtools_ok);
|
|
btn_uid_push->setEnabled(false);
|
|
} });
|
|
}
|
|
xsteam_ui::~xsteam_ui()
|
|
{
|
|
}
|
|
void xsteam_ui::xsteam_init_main_layout()
|
|
{
|
|
main_layout->addLayout(mind_layout);
|
|
main_layout->addLayout(foot_layout);
|
|
setLayout(main_layout);
|
|
}
|
|
void xsteam_ui::xsteam_init_info_layout()
|
|
{
|
|
info_layout = new QHBoxLayout();
|
|
info_txt_tag = new QLabel(tr("本工具建议配合SteamTools和Steam++使用"));
|
|
info_layout->addItem(sparcer_item);
|
|
info_layout->addWidget(info_txt_tag);
|
|
info_layout->addItem(sparcer_item);
|
|
}
|
|
void xsteam_ui::xsteam_init_mind_layout()
|
|
{
|
|
server_layout = new QHBoxLayout();
|
|
server_tag = new QLabel(tr("源数据:"));
|
|
server_tag->setObjectName("SRC_SERVER");
|
|
server_txt = new QComboBox();
|
|
server_state=new QLabel();
|
|
btn_server_edit = new QPushButton(tr("编辑源"));
|
|
btn_server_edit->setObjectName("EDIT");
|
|
btn_fetch_src_data = new QPushButton(tr("拉取"));
|
|
btn_fetch_src_data->setObjectName("FETCH");
|
|
btn_run_steamtools = new QPushButton(tr("SteamTools"));
|
|
btn_run_steamtools->setObjectName("RUN_STEAMTOOLS");
|
|
btn_run_steam = new QPushButton(tr("Steam"));
|
|
btn_run_steam->setObjectName("RUN_STEAM");
|
|
btn_run_steamdb = new QPushButton(tr("SteamDB"));
|
|
btn_run_steamdb->setObjectName("STEAM_DB");
|
|
btn_push_manifest = new QPushButton(tr("清单分享"));
|
|
btn_push_manifest->setObjectName("PUSH_MANIFEST");
|
|
|
|
server_layout->addWidget(server_tag);
|
|
server_layout->addWidget(server_txt);
|
|
server_layout->addWidget(server_state);
|
|
server_layout->addWidget(btn_fetch_src_data);
|
|
server_layout->addWidget(btn_server_edit);
|
|
server_layout->addWidget(btn_run_steam);
|
|
server_layout->addWidget(btn_run_steamtools);
|
|
server_layout->addWidget(btn_run_steamdb);
|
|
server_layout->addWidget(btn_push_manifest);
|
|
server_layout->setStretch(0, 1);
|
|
server_layout->setStretch(1, 7);
|
|
server_layout->setStretch(2, 1);
|
|
server_layout->setStretch(3, 1);
|
|
|
|
ip_layout = new QHBoxLayout();
|
|
ip_uid_tag = new QLabel(tr("游戏UID:"));
|
|
ip_uid_tag->setObjectName("GAME_UID");
|
|
|
|
ip_uid_edit = new QLineEdit("");
|
|
ip_uid_edit->setValidator(new QRegularExpressionValidator(QRegularExpression("[0-9]+$")));
|
|
ip_uid_edit->setMaxLength(8);
|
|
ip_layout->addWidget(ip_uid_tag);
|
|
ip_layout->addWidget(ip_uid_edit);
|
|
ip_layout->setContentsMargins(2, 2, 2, 2);
|
|
|
|
btn_dlc_push = new QPushButton(tr("获取DLC列表"));
|
|
btn_dlc_push->setObjectName("SET_DLC");
|
|
|
|
ip_iu_layout = new QHBoxLayout();
|
|
btn_uid_push = new QPushButton(tr("入库"));
|
|
btn_uid_push->setObjectName("INPUT");
|
|
|
|
btn_uid_update = new QPushButton(tr("更新"));
|
|
btn_uid_update->setObjectName("UPDATE");
|
|
ip_iu_layout->addWidget(btn_uid_push);
|
|
ip_iu_layout->addWidget(btn_uid_update);
|
|
ip_iu_layout->setContentsMargins(2, 2, 2, 2);
|
|
|
|
ip_data_layout = new QHBoxLayout();
|
|
// uid info
|
|
ip_uid_group_layout = new QHBoxLayout();
|
|
ip_uid_group = new QGroupBox(tr("游戏信息"));
|
|
ip_uid_group->setObjectName("GAME_INFO_GROUP");
|
|
ip_uid_table = new xsteam_view();
|
|
ip_uid_table->setObjectName("GAME_INFO_TABLE");
|
|
ip_uid_table->init_view(VIEW_MODE::UID_INFO);
|
|
ip_uid_group_layout->addWidget(ip_uid_table);
|
|
ip_uid_group_layout->setContentsMargins(2, 2, 2, 2);
|
|
ip_uid_group->setLayout(ip_uid_group_layout);
|
|
// all dlc info
|
|
ip_dlc_info_layout = new QVBoxLayout();
|
|
ip_all_dlc_group = new QGroupBox(tr("入库信息"));
|
|
ip_all_dlc_group->setObjectName("ALL_DLC_GROUP");
|
|
ip_all_dlc_table = new xsteam_view();
|
|
ip_all_dlc_table->setObjectName("ALL_DLC_TABLE");
|
|
ip_all_dlc_table->init_view(VIEW_MODE::ALL_DLC_INFO);
|
|
ip_in_dlc_table = new xsteam_view();
|
|
ip_in_dlc_table->setObjectName("IN_DLC_TABLE");
|
|
ip_in_dlc_table->init_view(VIEW_MODE::IN_DLC_INFO);
|
|
|
|
ip_dlc_info_layout->addLayout(ip_layout);
|
|
ip_dlc_info_layout->addWidget(btn_dlc_push);
|
|
ip_dlc_info_layout->addWidget(ip_in_dlc_table);
|
|
ip_dlc_info_layout->addWidget(ip_all_dlc_table);
|
|
ip_dlc_info_layout->addLayout(ip_iu_layout);
|
|
|
|
ip_dlc_info_layout->setContentsMargins(2, 2, 2, 2);
|
|
ip_all_dlc_group->setLayout(ip_dlc_info_layout);
|
|
|
|
ip_data_layout->addWidget(ip_uid_group);
|
|
ip_data_layout->addWidget(ip_all_dlc_group);
|
|
|
|
ip_data_layout->setStretch(0, 8);
|
|
ip_data_layout->setStretch(1, 2);
|
|
|
|
mind_layout->addLayout(server_layout);
|
|
mind_layout->addLayout(info_layout);
|
|
mind_layout->addLayout(ip_data_layout);
|
|
}
|
|
void xsteam_ui::xsteam_init_foot_layout()
|
|
{
|
|
foot_status_data_layout = new QHBoxLayout();
|
|
version_tips = new QLabel(tr("version:"));
|
|
version_tips->setObjectName("VERSION_TIPS");
|
|
version_tips_txt = new QLabel(PROJECT_VERSION);
|
|
version_tips_txt->setObjectName("VERSION_TIPS_TXT");
|
|
state_tips_txt = new QLabel();
|
|
state_tips_txt->setObjectName("STATE_TIPS");
|
|
state_tips_txt->setAlignment(Qt::AlignCenter);
|
|
|
|
btn_xs_sets = new QPushButton();
|
|
btn_xs_sets->setMaximumSize(25, 25);
|
|
btn_xs_sets->setObjectName(tr("BTN_SETS"));
|
|
|
|
btn_xs_about = new QPushButton();
|
|
btn_xs_about->setMaximumSize(25, 25);
|
|
btn_xs_about->setObjectName(tr("BTN_ABOUT"));
|
|
|
|
foot_status_data_layout->addWidget(version_tips);
|
|
foot_status_data_layout->addWidget(version_tips_txt);
|
|
|
|
foot_status_data_layout->addItem(sparcer_item);
|
|
foot_status_data_layout->addWidget(state_tips_txt);
|
|
foot_status_data_layout->addItem(sparcer_item);
|
|
|
|
foot_status_data_layout->addWidget(btn_xs_sets);
|
|
foot_status_data_layout->addWidget(btn_xs_about);
|
|
foot_layout->addLayout(foot_status_data_layout);
|
|
xs_git_fetch = new xsteam_git_fetch();
|
|
}
|
|
void xsteam_ui::xsteam_init_style()
|
|
{
|
|
main_layout->setStretch(0, 1);
|
|
main_layout->setStretch(1, 7);
|
|
main_layout->setStretch(2, 1);
|
|
main_layout->setContentsMargins(5, 5, 5, 5);
|
|
}
|
|
void xsteam_ui::xsteam_init_connect()
|
|
{
|
|
ip_uid_table->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
ip_all_dlc_table->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
ip_in_dlc_table->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
connect(btn_server_edit, SIGNAL(clicked()), this, SLOT(slots_open_server_edit()));
|
|
connect(btn_xs_sets, SIGNAL(clicked()), this, SLOT(slots_open_setting()));
|
|
connect(btn_run_steam, SIGNAL(clicked()), this, SLOT(slots_run_steam_steamtools()));
|
|
connect(btn_run_steamtools, SIGNAL(clicked()), this, SLOT(slots_run_steam_steamtools()));
|
|
connect(btn_xs_about, SIGNAL(clicked()), this, SLOT(slots_open_about()));
|
|
connect(btn_fetch_src_data, SIGNAL(clicked()), this, SLOT(slots_fetch_src_data()));
|
|
connect(btn_uid_push, SIGNAL(clicked()), this, SLOT(slots_imput_update_uid_push()));
|
|
connect(btn_uid_update, SIGNAL(clicked()), this, SLOT(slots_imput_update_uid_push()));
|
|
connect(btn_run_steamdb, SIGNAL(clicked()), this, SLOT(slots_open_steamdb()));
|
|
connect(this, SIGNAL(signals_src_combobox_update()), this, SLOT(slots_server_combobox_load_data()));
|
|
connect(xs_git_fetch, SIGNAL(signal_fetch_return_msg(std::string)), this, SLOT(slots_msg_text(std::string)));
|
|
connect(xs_git_fetch, SIGNAL(signal_fetch_return_data(UidData)), this, SLOT(slots_table_append(UidData)));
|
|
connect(ip_uid_table->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)), this, SLOT(slots_selection_row(const QItemSelection &, const QItemSelection &)));
|
|
connect(ip_uid_table, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(slots_rightMenu(QPoint)));
|
|
connect(ip_all_dlc_table, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(slots_rightMenu(QPoint)));
|
|
connect(ip_in_dlc_table, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(slots_rightMenu(QPoint)));
|
|
connect(btn_dlc_push, SIGNAL(clicked()), this, SLOT(slots_get_uid_dlcs()));
|
|
connect(btn_push_manifest, SIGNAL(clicked()), this, SLOT(slots_push_manifest()));
|
|
connect(server_txt, SIGNAL(currentIndexChanged(int)), this, SLOT(slots_change_src_state(int)));
|
|
}
|
|
void xsteam_ui::slots_change_src_state(int index)
|
|
{
|
|
QPixmap xs_pixmap;
|
|
std::string url;
|
|
xs_pixmap.load(":res/img/btn/net_wait.png");
|
|
xs_pixmap = xs_pixmap.scaled(25,25,Qt::KeepAspectRatio);
|
|
server_state->setPixmap(xs_pixmap);
|
|
for (auto &i : _data.s_data)
|
|
{
|
|
if (i.src_name == server_txt->itemText(index))
|
|
{
|
|
url = i.src_url;
|
|
break;
|
|
}
|
|
}
|
|
if (url != "")
|
|
{
|
|
QFuture<void> future = QtConcurrent::run([=](std::string _url,QPixmap _pixmap) {
|
|
xsteam_curl* xs_curl=new xsteam_curl();
|
|
if(xs_curl->get_url_state(_url)){
|
|
_pixmap.load(":/res/img/btn/net_ok.png");
|
|
}else{
|
|
_pixmap.load(":/res/img/btn/net_error.png");
|
|
}
|
|
_pixmap=_pixmap.scaled(25,25,Qt::KeepAspectRatio);
|
|
server_state->setPixmap(_pixmap);
|
|
delete xs_curl;
|
|
xs_curl=nullptr;
|
|
},url,xs_pixmap);
|
|
}
|
|
}
|
|
void xsteam_ui::slots_get_uid_dlcs()
|
|
{
|
|
UidData uid_data;
|
|
uid_data.uid = ip_uid_edit->text().toStdString();
|
|
uid_data.s_name = server_txt->currentText().toStdString();
|
|
slots_msg_text("获取DLC信息...");
|
|
ip_all_dlc_table->item_clear();
|
|
ip_in_dlc_table->item_clear();
|
|
slots_disable_enable_function(false);
|
|
QFuture<void> future = QtConcurrent::run([=](UidData uid_data)
|
|
{
|
|
if (xsteam_curl_steam_id_app_info(uid_data))
|
|
{
|
|
ip_all_dlc_table->item_append(uid_data, VIEW_MODE::ALL_DLC_INFO);
|
|
xs_data = uid_data;
|
|
slots_msg_text("DLC信息获取完毕");
|
|
slots_disable_enable_function(true);
|
|
}
|
|
else
|
|
{
|
|
slots_msg_text("获取DLC信息失败!请检查UID是否正确&网络是否畅通");
|
|
slots_disable_enable_function(true);
|
|
} }, uid_data);
|
|
}
|
|
void xsteam_ui::slots_rightMenu(const QPoint &pos)
|
|
{
|
|
QTableView *signalSrc = (QTableView *)sender(); // 获取到了发送该信号按钮的指针
|
|
QModelIndex index = signalSrc->indexAt(pos);
|
|
if (sender()->objectName() == "GAME_INFO_TABLE")
|
|
{
|
|
if (index.row() > -1)
|
|
{
|
|
// 创建菜单对象
|
|
QMenu *m_menu = new QMenu(this);
|
|
QAction *delete_task = new QAction(tr("移除入库"), this);
|
|
delete_task->setData(1);
|
|
delete_task->setObjectName(signalSrc->objectName());
|
|
// 把QAction对象添加到菜单上
|
|
m_menu->addAction(delete_task);
|
|
// 连接鼠标右键点击信号
|
|
connect(delete_task, SIGNAL(triggered()), this, SLOT(slots_delete_uid_st()));
|
|
// 在鼠标右键点击的地方显示菜单
|
|
m_menu->exec(QCursor::pos());
|
|
QList<QAction *> list = m_menu->actions();
|
|
foreach (QAction *pAction, list)
|
|
{
|
|
delete pAction;
|
|
}
|
|
delete m_menu;
|
|
}
|
|
}
|
|
else if (sender()->objectName() == "ALL_DLC_TABLE")
|
|
{
|
|
if (index.row() > -1)
|
|
{
|
|
// 创建菜单对象
|
|
QMenu *m_menu = new QMenu(this);
|
|
QAction *add_task = new QAction(tr("增加DLC"), this);
|
|
add_task->setData(1);
|
|
add_task->setObjectName(signalSrc->objectName());
|
|
// 把QAction对象添加到菜单上
|
|
m_menu->addAction(add_task);
|
|
// 连接鼠标右键点击信号
|
|
connect(add_task, SIGNAL(triggered()), this, SLOT(slots_in_dlc_add()));
|
|
// 在鼠标右键点击的地方显示菜单
|
|
m_menu->exec(QCursor::pos());
|
|
QList<QAction *> list = m_menu->actions();
|
|
foreach (QAction *pAction, list)
|
|
{
|
|
delete pAction;
|
|
}
|
|
delete m_menu;
|
|
}
|
|
}
|
|
else if (sender()->objectName() == "IN_DLC_TABLE")
|
|
{
|
|
if (index.row() > -1)
|
|
{
|
|
// 创建菜单对象
|
|
QMenu *m_menu = new QMenu(this);
|
|
QAction *delete_task = new QAction(tr("移除DLC"), this);
|
|
delete_task->setData(1);
|
|
delete_task->setObjectName(signalSrc->objectName());
|
|
// 把QAction对象添加到菜单上
|
|
m_menu->addAction(delete_task);
|
|
// 连接鼠标右键点击信号
|
|
connect(delete_task, SIGNAL(triggered()), this, SLOT(slots_in_dlc_delete()));
|
|
// 在鼠标右键点击的地方显示菜单
|
|
m_menu->exec(QCursor::pos());
|
|
QList<QAction *> list = m_menu->actions();
|
|
foreach (QAction *pAction, list)
|
|
{
|
|
delete pAction;
|
|
}
|
|
delete m_menu;
|
|
}
|
|
}
|
|
}
|
|
void xsteam_ui::slots_in_dlc_delete()
|
|
{
|
|
int curRow = ip_in_dlc_table->currentIndex().row();
|
|
if (curRow > -1)
|
|
{
|
|
QAbstractItemModel *modessl = ip_in_dlc_table->model();
|
|
QModelIndex indextemp = modessl->index(curRow, 0);
|
|
QString dlc_id = modessl->data(indextemp).value<QString>();
|
|
modessl->removeRow(curRow);
|
|
ip_in_dlc_table->setModel(modessl);
|
|
xs_data.n_dlc.erase(std::remove(xs_data.n_dlc.begin(), xs_data.n_dlc.end(), dlc_id), xs_data.n_dlc.end());
|
|
slots_msg_text("删除DLC:" + dlc_id.toStdString() + "成功!");
|
|
}
|
|
}
|
|
void xsteam_ui::slots_in_dlc_add()
|
|
{
|
|
int curRow = ip_all_dlc_table->currentIndex().row();
|
|
if (curRow > -1)
|
|
{
|
|
QAbstractItemModel *modessl = ip_all_dlc_table->model();
|
|
QModelIndex indextemp = modessl->index(curRow, 0);
|
|
QString dlc_id = modessl->data(indextemp).value<QString>();
|
|
xs_data.n_dlc.push_back(dlc_id.toStdString());
|
|
ip_in_dlc_table->item_append(xs_data, VIEW_MODE::IN_DLC_INFO);
|
|
slots_msg_text("增加DLC:" + dlc_id.toStdString() + "成功!");
|
|
}
|
|
}
|
|
void xsteam_ui::slots_delete_uid_st()
|
|
{
|
|
int curRow = ip_uid_table->currentIndex().row();
|
|
if (curRow > -1)
|
|
{
|
|
QAbstractItemModel *modessl = ip_uid_table->model();
|
|
QModelIndex indextemp = modessl->index(curRow, 1);
|
|
QString d_uid = modessl->data(indextemp).value<QString>();
|
|
modessl->removeRow(curRow);
|
|
ip_uid_table->setModel(modessl);
|
|
QFuture<void> future = QtConcurrent::run([=](std::string _uid)
|
|
{ xsteam_delete_uid_st(_uid); }, d_uid.toStdString());
|
|
}
|
|
}
|
|
void xsteam_ui::slots_fetch_src_data()
|
|
{
|
|
slots_msg_text("正在拉取" + server_txt->currentText().toStdString() + "数据...");
|
|
slots_disable_enable_function(false);
|
|
QFuture<void> future = QtConcurrent::run([=]()
|
|
{
|
|
xsteam_git *xs_git = new xsteam_git();
|
|
connect(xs_git, SIGNAL(signal_git_return_msg(std::string)), this, SLOT(slots_msg_text(std::string)));
|
|
xs_git->branch_or_tags_set_opts("", server_txt->currentText().toStdString());
|
|
if(xs_git->branch_or_tags_remote_array()){
|
|
slots_msg_text("拉取"+server_txt->currentText().toStdString()+"完毕");
|
|
}else{
|
|
slots_msg_text("拉取"+server_txt->currentText().toStdString()+"失败");
|
|
}
|
|
delete xs_git;
|
|
xs_git = nullptr;
|
|
slots_disable_enable_function(true); });
|
|
}
|
|
void xsteam_ui::slots_selection_row(const QItemSelection ¤t, const QItemSelection &previous)
|
|
{
|
|
QModelIndexList indexes = current.indexes();
|
|
if (!indexes.isEmpty())
|
|
{
|
|
QModelIndex index = indexes.first();
|
|
QAbstractItemModel *model = ip_uid_table->model();
|
|
std::string uid = (model->data(model->index(index.row(), 1)).value<QString>()).toStdString();
|
|
for (auto x : _data.u_data)
|
|
{
|
|
if (x.uid == uid)
|
|
{
|
|
xs_data = x;
|
|
break;
|
|
}
|
|
}
|
|
for (int i = 0; i < server_txt->count(); ++i)
|
|
{
|
|
std::string item_str = server_txt->itemText(i).toStdString();
|
|
if (xs_data.s_name == item_str)
|
|
{
|
|
server_txt->setCurrentIndex(i);
|
|
break;
|
|
}
|
|
}
|
|
ip_uid_edit->setText(QString::fromStdString(xs_data.uid));
|
|
ip_all_dlc_table->item_append(xs_data, VIEW_MODE::ALL_DLC_INFO);
|
|
ip_in_dlc_table->item_append(xs_data, VIEW_MODE::IN_DLC_INFO);
|
|
}
|
|
}
|
|
|
|
void xsteam_ui::slots_open_steamdb()
|
|
{
|
|
QDesktopServices::openUrl(QUrl("https://steamdb.info/"));
|
|
}
|
|
|
|
void xsteam_ui::slots_msg_text(std::string info)
|
|
{
|
|
QFuture<void> future = QtConcurrent::run([=](std::string info)
|
|
{ state_tips_txt->setText(QString::fromStdString(info)); }, info);
|
|
}
|
|
void xsteam_ui::slots_disable_enable_function(bool state)
|
|
{
|
|
server_txt->setEnabled(state);
|
|
btn_server_edit->setEnabled(state);
|
|
btn_fetch_src_data->setEnabled(state);
|
|
btn_uid_push->setEnabled(state);
|
|
btn_run_steam->setEnabled(state);
|
|
btn_run_steamtools->setEnabled(state);
|
|
btn_uid_update->setEnabled(state);
|
|
btn_dlc_push->setEnabled(state);
|
|
}
|
|
void xsteam_ui::slots_server_combobox_load_data()
|
|
{
|
|
server_txt->clear();
|
|
for (auto &u : _data.s_data)
|
|
{
|
|
server_txt->addItem(QString::fromStdString(u.src_name));
|
|
}
|
|
server_txt->setCurrentIndex(0);
|
|
}
|
|
void xsteam_ui::table_load_ui_data()
|
|
{
|
|
for (auto x : _data.u_data)
|
|
{
|
|
ip_uid_table->item_append(x, VIEW_MODE::UID_INFO);
|
|
}
|
|
}
|
|
void xsteam_ui::slots_run_steam_steamtools()
|
|
{
|
|
|
|
QObject *obj = QObject::sender();
|
|
if (obj->objectName() == "RUN_STEAM")
|
|
{
|
|
xsteam_run_steam_steamtools(RUN_MODE::STEAM);
|
|
}
|
|
else if (obj->objectName() == "RUN_STEAMTOOLS")
|
|
{
|
|
xsteam_run_steam_steamtools(RUN_MODE::STEAMTOOLS);
|
|
}
|
|
}
|
|
void xsteam_ui::slots_push_manifest()
|
|
{
|
|
xs_push_manifest = xsteam_push_manifest::Instance();
|
|
xs_push_manifest->setMaximumSize(((QWidget *)this->parent())->width(), ((QWidget *)this->parent())->height() - 25);
|
|
xs_push_manifest->setGeometry(((QWidget *)this->parent())->geometry());
|
|
xs_push_manifest->exec();
|
|
}
|
|
void xsteam_ui::slots_open_server_edit()
|
|
{
|
|
xs_src_edit_ui = xsteam_src_edit_ui::Instance();
|
|
xs_src_edit_ui->setMaximumSize(660, 580);
|
|
xs_src_edit_ui->setGeometry(((QWidget *)this->parent())->geometry());
|
|
connect(xs_src_edit_ui, SIGNAL(signals_update()), this, SLOT(slots_server_combobox_load_data()));
|
|
xs_src_edit_ui->exec();
|
|
}
|
|
void xsteam_ui::slots_open_setting()
|
|
{
|
|
xs_sets_ui = xsteam_set_ui::Instance();
|
|
xs_sets_ui->setMaximumSize(660, 580);
|
|
xs_sets_ui->setGeometry(((QWidget *)this->parent())->geometry());
|
|
xs_sets_ui->exec();
|
|
}
|
|
void xsteam_ui::slots_open_about()
|
|
{
|
|
xs_about_ui = xsteam_about_ui::Instance();
|
|
xs_about_ui->setMaximumSize(440, 580);
|
|
xs_about_ui->setGeometry(((QWidget *)this->parent())->geometry());
|
|
xs_about_ui->exec();
|
|
}
|
|
|
|
void xsteam_ui::slots_table_append(UidData u_data)
|
|
{
|
|
if (xs_state == PUSH_MODE::PUSH_ADD)
|
|
{
|
|
// 增加条目到游戏表格
|
|
ip_uid_table->item_append(u_data, VIEW_MODE::UID_INFO);
|
|
// 清空状态显示
|
|
slots_msg_text(u_data.uid + "入库完毕!");
|
|
// 增加到全局变量内
|
|
_data.u_data.push_back(u_data);
|
|
// 写入data.json->保存功能
|
|
}
|
|
else if (xs_state == PUSH_MODE::PUSH_UPDATE)
|
|
{
|
|
for (auto &x : _data.u_data)
|
|
{
|
|
if (x.uid == u_data.uid)
|
|
{
|
|
x = u_data;
|
|
break;
|
|
}
|
|
}
|
|
ip_uid_table->item_clear();
|
|
table_load_ui_data();
|
|
slots_msg_text(u_data.uid + "更新完毕!");
|
|
}
|
|
QFuture<void> future = QtConcurrent::run([=]()
|
|
{ xsteam_save_data_write(); });
|
|
}
|
|
void xsteam_ui::slots_imput_update_uid_push()
|
|
{
|
|
bool steam_ok = false;
|
|
bool steamtools_ok = false;
|
|
if (ip_uid_edit->text().toStdString() == "")
|
|
{
|
|
slots_msg_text("入库UID不能为空");
|
|
return;
|
|
}
|
|
if (!xsteam_steam_steamtools_exists(steam_ok, steamtools_ok))
|
|
{
|
|
slots_msg_text("请检查steam和steamtools路径");
|
|
return;
|
|
}
|
|
if (!xsteam_src_data_exists(server_txt->currentText().toStdString()))
|
|
{
|
|
slots_msg_text("请先拉取源服务器清单列表到本地");
|
|
return;
|
|
}
|
|
if (sender()->objectName() == "INPUT")
|
|
{
|
|
if (xsteam_uid_exists(ip_uid_edit->text().toStdString()))
|
|
{
|
|
slots_msg_text("当前游戏已入库!请勿反复入库");
|
|
return;
|
|
}
|
|
xs_state = PUSH_MODE::PUSH_ADD;
|
|
}
|
|
else
|
|
{
|
|
xs_state = PUSH_MODE::PUSH_UPDATE;
|
|
}
|
|
slots_imput_uid_push();
|
|
}
|
|
void xsteam_ui::slots_imput_uid_push()
|
|
{
|
|
xs_data.s_name = server_txt->currentText().toStdString();
|
|
slots_disable_enable_function(false);
|
|
QFuture<void> future = QtConcurrent::run([=](UidData u_data)
|
|
{
|
|
xs_git_fetch->fecth_uid_to_steam(xs_data);
|
|
slots_disable_enable_function(true); }, xs_data);
|
|
}
|