557 lines
17 KiB
C++
557 lines
17 KiB
C++
#include "mainwindow.h"
|
|
|
|
using namespace std;
|
|
|
|
bool display = false;
|
|
extern QDialog Configuration;
|
|
extern Ui::Configuration config;
|
|
|
|
MainWindow::MainWindow(QWidget *parent)
|
|
: QMainWindow(parent)
|
|
, ui(new Ui::MainWindow)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
QCoreApplication::setOrganizationName("RsyncUI");
|
|
QCoreApplication::setApplicationName("RsyncUI");
|
|
|
|
// init shortcut
|
|
loadSettings();
|
|
config.setupUi(&Configuration);
|
|
config.UnitCombobox->addItems({tr("Byte"), tr("KB"), tr("MB"), tr("GB"), tr("TB"), tr("PB")});
|
|
|
|
// init of About
|
|
this->about.description = tr(this->about.description.toStdString().c_str());
|
|
|
|
// connectors
|
|
connect(&downloadO, &downloadFile::progressSignal, ui->progressBar, &QProgressBar::setValue);
|
|
connect(&downloadO, &downloadFile::finishedSignal, this, &MainWindow::downloadFinished);
|
|
connect(this, &MainWindow::stopDownloading, &downloadO, &downloadFile::cancelled);
|
|
connect(config.buttonBox, SIGNAL(accepted()), this, SLOT(on_buttonBox_accepted()));
|
|
|
|
// init of widgets
|
|
ui->ktreewidgetsearchline->setTreeWidget(ui->treeWidget);
|
|
ui->ktreewidgetsearchline->setCaseSensitivity(Qt::CaseInsensitive);
|
|
ui->treeWidget->setHeaderLabels({tr("Path"), tr("Size")} );
|
|
if (this->settings.contains("connexion/lastServer"))
|
|
{
|
|
ui->portEdit->setText(this->settings.value("connexion/port").toString());
|
|
ui->khistorycombobox->setCurrentText(this->settings.value("connexion/lastServer").toString());
|
|
}else
|
|
{
|
|
ui->portEdit->text() = QString::number(this->connexion.port);
|
|
ui->khistorycombobox->clear();
|
|
}
|
|
|
|
|
|
ui->progressBar->hide();
|
|
|
|
populateList();
|
|
}
|
|
|
|
MainWindow::~MainWindow()
|
|
{
|
|
delete ui;
|
|
}
|
|
|
|
// Closing window has been clicked
|
|
void MainWindow::closeEvent (QCloseEvent *event)
|
|
{
|
|
QMessageBox::StandardButton reply;
|
|
|
|
// saving settings
|
|
saveSettings();
|
|
|
|
if (ui->listDownload->count() != 0) // some downloads waiting
|
|
{
|
|
// Asking for stopping or continuing
|
|
reply = QMessageBox::question(
|
|
this,
|
|
"RsyncUI",
|
|
tr("Exiting will stop downloading, and will clear the download queue.\n Do you want to exit ?"),
|
|
QMessageBox::Yes|QMessageBox::No,
|
|
QMessageBox::No);
|
|
if (reply == QMessageBox::No)
|
|
{
|
|
// continuing
|
|
event->ignore();
|
|
return;
|
|
}else
|
|
{
|
|
// emission of signal to downloading thread and stopping
|
|
emit (stopDownloading(this->downloading.pid));
|
|
waitpid(this->downloading.pid, NULL, WUNTRACED);
|
|
}
|
|
}
|
|
event->accept();
|
|
}
|
|
|
|
// Populate treeview with list of files
|
|
void MainWindow::populateTree()
|
|
{
|
|
stringstream ss;
|
|
vector<string> path;
|
|
|
|
// Clear treewidget
|
|
ui->treeWidget->clear();
|
|
if (!this->connexion.server.empty() and this->connexion.port > 0 and this->connexion.port < 65536)
|
|
{
|
|
// setting cursor to "Wait"
|
|
QGuiApplication::setOverrideCursor(Qt::WaitCursor);
|
|
|
|
if (validateServer(this->connexion.server))
|
|
{
|
|
// server is validated
|
|
path = explode(ui->listWidget->currentItem()->text().toStdString(), '\n', 2);
|
|
scanDir(this->connexion.server, this->connexion.port, NULL, path[0].append("/") );
|
|
}
|
|
// Restoring cursor
|
|
QGuiApplication::restoreOverrideCursor();
|
|
}
|
|
}
|
|
|
|
// Populate Listview with list of services
|
|
void MainWindow::populateList()
|
|
{
|
|
stringstream ss;
|
|
QString str;
|
|
QString server;
|
|
int port;
|
|
|
|
server = ui->khistorycombobox->currentText();
|
|
port = ui->portEdit->text().toUInt();
|
|
if ((server.toStdString() != this->connexion.server) or (port != this->connexion.port))
|
|
{
|
|
// clearing listwidget
|
|
ui->listWidget->clear();
|
|
this->connexion.server.assign(server.toStdString());
|
|
this->connexion.port = port;
|
|
|
|
// verify if server is in history
|
|
this->settings.beginGroup("connexion/server");
|
|
if (this->settings.contains(server))
|
|
{
|
|
// server is in history and completing port value
|
|
port = this->settings.value(server).toUInt();
|
|
ui->portEdit->setText(QString::number(port));
|
|
this->connexion.port = port;
|
|
}
|
|
|
|
if (!server.isEmpty() and (port > 0 and port < 65536))
|
|
{
|
|
if (validateServer(server.toStdString()))
|
|
{
|
|
|
|
if (!this->settings.contains(server))
|
|
{
|
|
cout << server.toStdString() << endl;
|
|
// storing serverURL and port in settings
|
|
this->settings.setValue(server, port);
|
|
this->settings.sync();
|
|
|
|
// storing in history of combobox
|
|
ui->khistorycombobox->addToHistory(server);
|
|
}
|
|
// "waiting" cursor
|
|
// load and display rsync services of the rsync server
|
|
QGuiApplication::setOverrideCursor(Qt::WaitCursor);
|
|
listServices();
|
|
QGuiApplication::restoreOverrideCursor(); //setOverrideCursor(Qt::ArrowCursor);
|
|
}
|
|
}
|
|
this->settings.endGroup();
|
|
QGuiApplication::restoreOverrideCursor(); //setOverrideCursor(Qt::ArrowCursor);
|
|
}
|
|
}
|
|
|
|
//list services of the rsync server
|
|
void MainWindow::listServices()
|
|
{
|
|
char cmd[4096];
|
|
string line;
|
|
string errorRsync;
|
|
vector<string> v;
|
|
char service[4096];
|
|
|
|
sprintf(cmd, "rsync --contimeout=10 -P \"%s::\" --port %d ", this->connexion.server.c_str(), this->connexion.port );
|
|
redi::ipstream in(cmd, redi::pstreams::pstdout | redi::pstreams::pstderr);
|
|
while (getline(in.out(), line))
|
|
{
|
|
boost::replace_all(line," ","");
|
|
boost::replace_all(line, "\t", " - ");
|
|
v = explode(line, ' ', 3 );
|
|
sprintf(service, "%s\n\t%s", v[0].c_str(), v[2].c_str());
|
|
ui->listWidget->addItem(service);
|
|
}
|
|
}
|
|
|
|
// connect to rsync server to get list of files
|
|
void MainWindow::scanDir(string server, int portN, QTreeWidgetItem *parent, string path)
|
|
{
|
|
char cmd[4096];
|
|
string line;
|
|
string errorRsync;
|
|
vector<string> v;
|
|
QTreeWidgetItem * item;
|
|
char npath[4096];
|
|
|
|
sprintf(cmd, "rsync --contimeout=10 -P \"%s::%s\" --port %d ", server.c_str(), path.c_str(), portN );
|
|
redi::ipstream in(cmd, redi::pstreams::pstdout | redi::pstreams::pstderr);
|
|
|
|
while (getline(in.out(), line))
|
|
{
|
|
|
|
v = explode(line, ' ', 5);
|
|
if (v.size() == 5)
|
|
{
|
|
if (v[4].at(0) != '.' and (v[0].at(0) == '-' or v[0].at(0) == 'd'))
|
|
{
|
|
if (parent != NULL)
|
|
{
|
|
item = addTreeChild(parent,QString::fromStdString(v[4]), QString::fromStdString(v[1]));
|
|
}else
|
|
{
|
|
item = addTreeRoot(QString::fromStdString(v[4]), QString::fromStdString(v[1]));
|
|
}
|
|
if (v[0].at(0) == 'd')
|
|
{
|
|
sprintf(npath, "%s%s/", path.c_str(), v[4].c_str());
|
|
scanDir(server, portN, item, npath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// if reading stdout stopped at EOF then reset the state:
|
|
if (in.eof() && in.fail())
|
|
in.clear();
|
|
// read child's stderr
|
|
while (getline(in.err(), line))
|
|
{
|
|
cout << "stderr: " << line << endl;
|
|
errorRsync.append(line);
|
|
errorRsync.append("\n");
|
|
}
|
|
if ( !errorRsync.empty())
|
|
{
|
|
QMessageBox::warning(
|
|
this,
|
|
"RsyncUI",
|
|
errorRsync.c_str());
|
|
}
|
|
|
|
}
|
|
|
|
// Verify if server address is IP address
|
|
bool MainWindow::isIpAddress(string server)
|
|
{
|
|
vector<string> r;
|
|
int elementN;
|
|
QString qr;
|
|
bool ok;
|
|
|
|
r = explode(server, '.', 5);
|
|
if (r.size() == 4)
|
|
{
|
|
for (auto element : r)
|
|
{
|
|
elementN = QString::fromStdString(element).toInt(&ok);
|
|
if (elementN < 0 or elementN > 255 or ok == false)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// validate address server
|
|
bool MainWindow::validateServer(string server)
|
|
{
|
|
char cmd[512];
|
|
string line;
|
|
string errorDig;
|
|
bool flag = false;
|
|
|
|
sprintf(cmd, "dig %s", server.c_str());
|
|
redi::ipstream in(cmd, redi::pstreams::pstdout | redi::pstreams::pstderr);
|
|
|
|
while (getline(in.out(), line))
|
|
{
|
|
//cout << "stdout: " << line << '\n';
|
|
if (line.find(";; ANSWER SECTION:") != string::npos)
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
// if reading stdout stopped at EOF then reset the state:
|
|
if (in.eof() && in.fail())
|
|
in.clear();
|
|
// read child's stderr
|
|
while (std::getline(in.err(), line))
|
|
{
|
|
cout << "stderr: " << line << '\n';
|
|
errorDig.append(line);
|
|
errorDig.append("\n");
|
|
}
|
|
if ( !errorDig.empty())
|
|
{
|
|
QMessageBox::warning(
|
|
this,
|
|
"RsyncUI",
|
|
errorDig.c_str()
|
|
);
|
|
}
|
|
if ( flag == false)
|
|
{
|
|
flag = isIpAddress(server);
|
|
}
|
|
if ( flag == false)
|
|
{
|
|
QMessageBox::warning(
|
|
this,
|
|
"RsyncUI",
|
|
tr("server does not exists" )
|
|
);
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// slot activated when combobox is changed
|
|
void MainWindow::on_khistorycombobox_currentIndexChanged(int i)
|
|
{
|
|
on_connectButton_clicked();
|
|
}
|
|
|
|
// slot activated when button connection is clicked
|
|
void MainWindow::on_connectButton_clicked()
|
|
{
|
|
populateList();
|
|
}
|
|
|
|
// add a dir in treeview
|
|
QTreeWidgetItem * MainWindow::addTreeRoot(QString name, QString fileSize)
|
|
{
|
|
// QTreeWidgetItem(QTreeWidget * parent, int type = Type)
|
|
QTreeWidgetItem *treeItem = new QTreeWidgetItem(ui->treeWidget);
|
|
|
|
// QTreeWidgetItem::setText(int column, const QString & text)
|
|
treeItem->setText(0, name);
|
|
treeItem->setText(1, fileSize);
|
|
return treeItem;
|
|
}
|
|
|
|
// add a file in treeview
|
|
QTreeWidgetItem * MainWindow::addTreeChild(QTreeWidgetItem *parent, QString name, QString fileSize)
|
|
{
|
|
// QTreeWidgetItem(QTreeWidget * parent, int type = Type)
|
|
QTreeWidgetItem *treeItem = new QTreeWidgetItem();
|
|
|
|
// QTreeWidgetItem::setText(int column, const QString & text)
|
|
treeItem->setText(0, name);
|
|
treeItem->setText(1, fileSize);
|
|
|
|
// QTreeWidgetItem::addChild(QTreeWidgetItem * child)
|
|
parent->addChild(treeItem);
|
|
return treeItem;
|
|
}
|
|
|
|
// Slot acivated when a service in the list is clicked
|
|
void MainWindow::on_listWidget_clicked()
|
|
{
|
|
vector<string> v;
|
|
v = explode(ui->listWidget->currentItem()->text().toStdString(), '\n', 2);
|
|
this->downloading.service = v[0];
|
|
populateTree();
|
|
}
|
|
|
|
//Slot activated when a file is clicked in the treeview
|
|
void MainWindow::on_treeWidget_itemClicked(QTreeWidgetItem *item)
|
|
{
|
|
QFuture<void> future;
|
|
QFileDialog dialog;
|
|
|
|
item = ui->treeWidget->currentItem();
|
|
this->downloading.path = item->text(0).toStdString();
|
|
while(item->parent() != NULL)
|
|
{
|
|
item = item->parent();
|
|
this->downloading.path = item->text(0).toStdString() + "/" + this->downloading.path;
|
|
};
|
|
|
|
if (this->downloading.savePath.empty())
|
|
{
|
|
on_DefaultSaveFolder_triggered();
|
|
}
|
|
if (!this->downloading.savePath.empty() && this->downloading.pid == 0)
|
|
{
|
|
startDownloading();
|
|
}
|
|
ui->listDownload->addItem(QString::fromStdString(this->downloading.path));
|
|
}
|
|
|
|
// Launch the thread which download the file
|
|
void MainWindow::startDownloading()
|
|
{
|
|
ui->progressBar->setValue(0);
|
|
ui->progressBar->show();
|
|
|
|
QtConcurrent::run(&this->downloadO, &downloadFile::download, this);
|
|
|
|
}
|
|
|
|
// Slot stopping download
|
|
void MainWindow::stoppingDownload()
|
|
{
|
|
emit (stopDownloading(this->downloading.pid));
|
|
}
|
|
|
|
// when download is finished, launch download of next file in queue
|
|
void MainWindow::downloadFinished()
|
|
{
|
|
ui->progressBar->hide();
|
|
delete ui->listDownload->takeItem(0);
|
|
this->downloading.pid = 0;
|
|
if (ui->listDownload->count() != 0)
|
|
{
|
|
this->downloading.path = ui->listDownload->item(0)->text().toStdString();
|
|
startDownloading();
|
|
}
|
|
}
|
|
|
|
// Slot activated when a line is clicked in queue list
|
|
void MainWindow::on_listDownload_itemClicked(QListWidgetItem *item)
|
|
{
|
|
QFileDialog dialog;
|
|
QMessageBox::StandardButton reply;
|
|
|
|
//cout << item->text().toStdString() << endl;
|
|
if (item->listWidget()->row(item) == 0)
|
|
{
|
|
reply = QMessageBox::question(
|
|
this,
|
|
"RsyncUI",
|
|
tr("Do you want to stop downloading and delete this file from download queue ?"),
|
|
QMessageBox::Yes|QMessageBox::No,
|
|
QMessageBox::No);
|
|
if (reply == QMessageBox::Yes)
|
|
{
|
|
emit (stopDownloading(this->downloading.pid));
|
|
}
|
|
}else
|
|
{
|
|
reply = QMessageBox::question(
|
|
this,
|
|
"RsyncUI",
|
|
tr("Do you want to delete this file from download queue ?"),
|
|
QMessageBox::Yes|QMessageBox::No,
|
|
QMessageBox::No);
|
|
if (reply == QMessageBox::Yes)
|
|
{
|
|
ui->listDownload->removeItemWidget(item);
|
|
delete item;
|
|
}
|
|
}
|
|
}
|
|
|
|
// load settings
|
|
void MainWindow::loadSettings()
|
|
{
|
|
// restoring geometry and state of wondow and widgets
|
|
this->restoreGeometry(settings.value("window/geometry").toByteArray());
|
|
this->restoreState(settings.value("window/state").toByteArray());
|
|
ui->treeWidget->header()->restoreState(settings.value("treeView/state").toByteArray());
|
|
ui->splitter->restoreState(settings.value("splitter/state").toByteArray());
|
|
ui->splitter_2->restoreState(settings.value("splitter2/state").toByteArray());
|
|
|
|
// loading connexion settings
|
|
// loading servers history
|
|
this->settings.beginGroup("connexion/server");
|
|
QStringList servers = this->settings.allKeys();
|
|
this->settings.endGroup();
|
|
for( const QString &server : servers )
|
|
{
|
|
ui->khistorycombobox->addToHistory(server);
|
|
}
|
|
|
|
// loading save path
|
|
this->downloading.savePath = this->settings.value("Folder").toString().toStdString();
|
|
|
|
// loading bandwidth limit
|
|
this->connexion.bandwidthLimit = this->settings.value("bandwidthlimit").toUInt();
|
|
this->connexion.bandwidthLimitUnit = this->settings.value("bandwidthlimitunit").toString().toStdString();
|
|
}
|
|
|
|
// save settings
|
|
void MainWindow::saveSettings()
|
|
{
|
|
this->settings.setValue("window/geometry", saveGeometry());
|
|
this->settings.setValue("window/state", saveState());
|
|
this->settings.setValue("treeView/state", ui->treeWidget->header()->saveState());
|
|
this->settings.setValue("splitter/state", ui->splitter->saveState());
|
|
this->settings.setValue("splitter2/state", ui->splitter_2->saveState());
|
|
this->settings.setValue("connexion/lastServer", QString::fromStdString(this->connexion.server));
|
|
this->settings.setValue("connexion/lastPort", QString::number(this->connexion.port));
|
|
this->settings.sync();
|
|
}
|
|
|
|
// About
|
|
void MainWindow::on_actionAbout_triggered()
|
|
{
|
|
QString text = this->about.description + "\n\n" +
|
|
tr("Version") + ": " + this->about.version + "\n" +
|
|
tr("Licence") + ": " + this->about.licence + "\n" +
|
|
tr("Author") + ": " + this->about.author + "\n" +
|
|
tr("EMail") + ": " + this->about.email + "\n" +
|
|
tr("Source code") + ": " + this->about.git;
|
|
QMessageBox::about(this, this->about.title, text);
|
|
}
|
|
|
|
// About QT
|
|
void MainWindow::on_actionAbout_Qt_triggered()
|
|
{
|
|
QMessageBox::aboutQt(this);
|
|
}
|
|
|
|
// Activated when menu "change folder" is clicked
|
|
void MainWindow::on_DefaultSaveFolder_triggered()
|
|
{
|
|
QFileDialog dialog;
|
|
|
|
this->downloading.savePath = dialog.getExistingDirectory(this, tr("Choose directory to save file"), this->downloading.dirPath, QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks).toStdString();
|
|
// this->downloading.dirPath = this->downloading.savePath.c_str();
|
|
this->settings.setValue("Folder/", this->downloading.savePath.c_str());
|
|
this->settings.sync();
|
|
}
|
|
|
|
// Activated when menu "settings" is clicked
|
|
void MainWindow::on_action_Settings_triggered()
|
|
{
|
|
config.UnitCombobox->setCurrentText(QString::fromStdString(this->connexion.bandwidthLimitUnit));
|
|
config.spinBox->setValue(this->connexion.bandwidthLimit);
|
|
Configuration.show();
|
|
}
|
|
|
|
// Acivated when "Ok" is clicked in Configuration window
|
|
void MainWindow::on_buttonBox_accepted()
|
|
{
|
|
QString unit;
|
|
QString bw;
|
|
|
|
bw = config.spinBox->text();
|
|
if (bw.toInt() == 0)
|
|
{
|
|
this->connexion.bandwidthLimit = 1000;
|
|
this->connexion.bandwidthLimitUnit = tr("PB").toStdString();
|
|
}else
|
|
{
|
|
this->connexion.bandwidthLimit = config.spinBox->value();
|
|
this->connexion.bandwidthLimitUnit = config.UnitCombobox->currentText().toStdString();
|
|
}
|
|
this->settings.setValue("bandwidthlimit", this->connexion.bandwidthLimit);
|
|
this->settings.setValue("bandwidthlimitunit", this->connexion.bandwidthLimitUnit.c_str());
|
|
this->settings.sync();
|
|
}
|