RemoteLinux: Inline genericlinuxdeviceconfigurationwidget.ui

Change-Id: I1f93b7886bb8d0217a9e169990e20361e540aec4
Reviewed-by: Eike Ziller <eike.ziller@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
This commit is contained in:
hjk
2022-07-14 17:02:19 +02:00
parent 421cdd8021
commit 034acdeeb2
6 changed files with 154 additions and 357 deletions

View File

@@ -24,124 +24,186 @@
****************************************************************************/
#include "genericlinuxdeviceconfigurationwidget.h"
#include "ui_genericlinuxdeviceconfigurationwidget.h"
#include "sshkeycreationdialog.h"
#include <coreplugin/coreconstants.h>
#include <projectexplorer/devicesupport/idevice.h>
#include <projectexplorer/devicesupport/sshparameters.h>
#include <utils/portlist.h>
#include <utils/fancylineedit.h>
#include <utils/layoutbuilder.h>
#include <utils/pathchooser.h>
#include <utils/portlist.h>
#include <utils/utilsicons.h>
#include <QCheckBox>
#include <QLabel>
#include <QLineEdit>
#include <QPushButton>
#include <QRadioButton>
#include <QSpacerItem>
#include <QSpinBox>
using namespace ProjectExplorer;
using namespace RemoteLinux;
using namespace Utils;
namespace RemoteLinux::Internal {
GenericLinuxDeviceConfigurationWidget::GenericLinuxDeviceConfigurationWidget(
const IDevice::Ptr &deviceConfig) :
IDeviceWidget(deviceConfig),
m_ui(new Ui::GenericLinuxDeviceConfigurationWidget)
const IDevice::Ptr &device) :
IDeviceWidget(device)
{
m_ui->setupUi(this);
connect(m_ui->hostLineEdit, &QLineEdit::editingFinished,
resize(556, 309);
m_defaultAuthButton = new QRadioButton(tr("Default"), this);
m_keyButton = new QRadioButton(tr("Specific &key"));
m_hostLineEdit = new QLineEdit(this);
m_hostLineEdit->setPlaceholderText(tr("IP or host name of the device"));
m_sshPortSpinBox = new QSpinBox(this);
m_sshPortSpinBox->setMinimum(0);
m_sshPortSpinBox->setMaximum(65535);
m_sshPortSpinBox->setValue(22);
m_hostKeyCheckBox = new QCheckBox(tr("&Check host key"));
m_portsLineEdit = new QLineEdit(this);
m_portsLineEdit->setToolTip(tr("You can enter lists and ranges like this: '1024,1026-1028,1030'."));
m_portsWarningLabel = new QLabel(this);
m_timeoutSpinBox = new QSpinBox(this);
m_timeoutSpinBox->setMaximum(10000);
m_timeoutSpinBox->setSingleStep(10);
m_timeoutSpinBox->setValue(1000);
m_timeoutSpinBox->setSuffix(tr("s"));
m_userLineEdit = new QLineEdit(this);
m_keyLabel = new QLabel(tr("Private key file:"));
m_keyFileLineEdit = new Utils::PathChooser(this);
auto createKeyButton = new QPushButton(tr("Create New..."));
m_machineTypeValueLabel = new QLabel(this);
m_gdbServerLineEdit = new QLineEdit(this);
m_gdbServerLineEdit->setPlaceholderText(tr("Leave empty to look up executable in $PATH"));
auto sshPortLabel = new QLabel(tr("&SSH port:"));
sshPortLabel->setBuddy(m_sshPortSpinBox);
using namespace Layouting;
const Break nl;
const Stretch st;
Form {
tr("Machine type:"), m_machineTypeValueLabel, st, nl,
tr("Authentication type:"), m_defaultAuthButton, m_keyButton, st, nl,
tr("&Host name:"), m_hostLineEdit, sshPortLabel, m_sshPortSpinBox, m_hostKeyCheckBox, st, nl,
tr("Free ports:"), m_portsLineEdit, m_portsWarningLabel, tr("Timeout:"), m_timeoutSpinBox, st, nl,
tr("&Username:"), m_userLineEdit, st, nl,
m_keyLabel, m_keyFileLineEdit, createKeyButton, st, nl,
tr("GDB server executable:"), m_gdbServerLineEdit, st, nl
}.attachTo(this);
connect(m_hostLineEdit, &QLineEdit::editingFinished,
this, &GenericLinuxDeviceConfigurationWidget::hostNameEditingFinished);
connect(m_ui->userLineEdit, &QLineEdit::editingFinished,
connect(m_userLineEdit, &QLineEdit::editingFinished,
this, &GenericLinuxDeviceConfigurationWidget::userNameEditingFinished);
connect(m_ui->keyFileLineEdit, &PathChooser::editingFinished,
connect(m_keyFileLineEdit, &PathChooser::editingFinished,
this, &GenericLinuxDeviceConfigurationWidget::keyFileEditingFinished);
connect(m_ui->keyFileLineEdit, &PathChooser::browsingFinished,
connect(m_keyFileLineEdit, &PathChooser::browsingFinished,
this, &GenericLinuxDeviceConfigurationWidget::keyFileEditingFinished);
connect(m_ui->keyButton, &QAbstractButton::toggled,
connect(m_keyButton, &QAbstractButton::toggled,
this, &GenericLinuxDeviceConfigurationWidget::authenticationTypeChanged);
connect(m_ui->timeoutSpinBox, &QAbstractSpinBox::editingFinished,
connect(m_timeoutSpinBox, &QAbstractSpinBox::editingFinished,
this, &GenericLinuxDeviceConfigurationWidget::timeoutEditingFinished);
connect(m_ui->timeoutSpinBox, QOverload<int>::of(&QSpinBox::valueChanged),
connect(m_timeoutSpinBox, &QSpinBox::valueChanged,
this, &GenericLinuxDeviceConfigurationWidget::timeoutEditingFinished);
connect(m_ui->sshPortSpinBox, &QAbstractSpinBox::editingFinished,
connect(m_sshPortSpinBox, &QAbstractSpinBox::editingFinished,
this, &GenericLinuxDeviceConfigurationWidget::sshPortEditingFinished);
connect(m_ui->sshPortSpinBox, QOverload<int>::of(&QSpinBox::valueChanged),
connect(m_sshPortSpinBox, &QSpinBox::valueChanged,
this, &GenericLinuxDeviceConfigurationWidget::sshPortEditingFinished);
connect(m_ui->portsLineEdit, &QLineEdit::editingFinished,
connect(m_portsLineEdit, &QLineEdit::editingFinished,
this, &GenericLinuxDeviceConfigurationWidget::handleFreePortsChanged);
connect(m_ui->createKeyButton, &QAbstractButton::clicked,
connect(createKeyButton, &QAbstractButton::clicked,
this, &GenericLinuxDeviceConfigurationWidget::createNewKey);
connect(m_ui->gdbServerLineEdit, &QLineEdit::editingFinished,
connect(m_gdbServerLineEdit, &QLineEdit::editingFinished,
this, &GenericLinuxDeviceConfigurationWidget::gdbServerEditingFinished);
connect(m_ui->hostKeyCheckBox, &QCheckBox::toggled,
connect(m_hostKeyCheckBox, &QCheckBox::toggled,
this, &GenericLinuxDeviceConfigurationWidget::hostKeyCheckingChanged);
m_ui->gdbServerLineEdit->setToolTip(m_ui->gdbServerLineEdit->placeholderText());
m_gdbServerLineEdit->setToolTip(m_gdbServerLineEdit->placeholderText());
initGui();
}
GenericLinuxDeviceConfigurationWidget::~GenericLinuxDeviceConfigurationWidget()
{
delete m_ui;
}
GenericLinuxDeviceConfigurationWidget::~GenericLinuxDeviceConfigurationWidget() = default;
void GenericLinuxDeviceConfigurationWidget::authenticationTypeChanged()
{
SshParameters sshParams = device()->sshParameters();
const bool useKeyFile = m_ui->keyButton->isChecked();
const bool useKeyFile = m_keyButton->isChecked();
sshParams.authenticationType = useKeyFile
? SshParameters::AuthenticationTypeSpecificKey
: SshParameters::AuthenticationTypeAll;
device()->setSshParameters(sshParams);
m_ui->keyFileLineEdit->setEnabled(useKeyFile);
m_ui->keyLabel->setEnabled(useKeyFile);
m_keyFileLineEdit->setEnabled(useKeyFile);
m_keyLabel->setEnabled(useKeyFile);
}
void GenericLinuxDeviceConfigurationWidget::hostNameEditingFinished()
{
SshParameters sshParams = device()->sshParameters();
sshParams.setHost(m_ui->hostLineEdit->text().trimmed());
sshParams.setHost(m_hostLineEdit->text().trimmed());
device()->setSshParameters(sshParams);
}
void GenericLinuxDeviceConfigurationWidget::sshPortEditingFinished()
{
SshParameters sshParams = device()->sshParameters();
sshParams.setPort(m_ui->sshPortSpinBox->value());
sshParams.setPort(m_sshPortSpinBox->value());
device()->setSshParameters(sshParams);
}
void GenericLinuxDeviceConfigurationWidget::timeoutEditingFinished()
{
SshParameters sshParams = device()->sshParameters();
sshParams.timeout = m_ui->timeoutSpinBox->value();
sshParams.timeout = m_timeoutSpinBox->value();
device()->setSshParameters(sshParams);
}
void GenericLinuxDeviceConfigurationWidget::userNameEditingFinished()
{
SshParameters sshParams = device()->sshParameters();
sshParams.setUserName(m_ui->userLineEdit->text());
sshParams.setUserName(m_userLineEdit->text());
device()->setSshParameters(sshParams);
}
void GenericLinuxDeviceConfigurationWidget::keyFileEditingFinished()
{
SshParameters sshParams = device()->sshParameters();
sshParams.privateKeyFile = m_ui->keyFileLineEdit->filePath();
sshParams.privateKeyFile = m_keyFileLineEdit->filePath();
device()->setSshParameters(sshParams);
}
void GenericLinuxDeviceConfigurationWidget::gdbServerEditingFinished()
{
device()->setDebugServerPath(device()->filePath(m_ui->gdbServerLineEdit->text()));
device()->setDebugServerPath(device()->filePath(m_gdbServerLineEdit->text()));
}
void GenericLinuxDeviceConfigurationWidget::handleFreePortsChanged()
{
device()->setFreePorts(PortList::fromString(m_ui->portsLineEdit->text()));
device()->setFreePorts(PortList::fromString(m_portsLineEdit->text()));
updatePortsWarningLabel();
}
void GenericLinuxDeviceConfigurationWidget::setPrivateKey(const FilePath &path)
{
m_ui->keyFileLineEdit->setFilePath(path);
m_keyFileLineEdit->setFilePath(path);
keyFileEditingFinished();
}
@@ -173,47 +235,50 @@ void GenericLinuxDeviceConfigurationWidget::updateDeviceFromUi()
void GenericLinuxDeviceConfigurationWidget::updatePortsWarningLabel()
{
m_ui->portsWarningLabel->setVisible(!device()->freePorts().hasMore());
m_portsWarningLabel->setVisible(!device()->freePorts().hasMore());
}
void GenericLinuxDeviceConfigurationWidget::initGui()
{
if (device()->machineType() == IDevice::Hardware)
m_ui->machineTypeValueLabel->setText(tr("Physical Device"));
m_machineTypeValueLabel->setText(tr("Physical Device"));
else
m_ui->machineTypeValueLabel->setText(tr("Emulator"));
m_ui->portsWarningLabel->setPixmap(Utils::Icons::CRITICAL.pixmap());
m_ui->portsWarningLabel->setToolTip(QLatin1String("<font color=\"red\">")
m_machineTypeValueLabel->setText(tr("Emulator"));
m_portsWarningLabel->setPixmap(Utils::Icons::CRITICAL.pixmap());
m_portsWarningLabel->setToolTip(QLatin1String("<font color=\"red\">")
+ tr("You will need at least one port.") + QLatin1String("</font>"));
m_ui->keyFileLineEdit->setExpectedKind(PathChooser::File);
m_ui->keyFileLineEdit->setHistoryCompleter(QLatin1String("Ssh.KeyFile.History"));
m_ui->keyFileLineEdit->lineEdit()->setMinimumWidth(0);
m_keyFileLineEdit->setExpectedKind(PathChooser::File);
m_keyFileLineEdit->setHistoryCompleter(QLatin1String("Ssh.KeyFile.History"));
m_keyFileLineEdit->lineEdit()->setMinimumWidth(0);
QRegularExpressionValidator * const portsValidator
= new QRegularExpressionValidator(QRegularExpression(PortList::regularExpression()), this);
m_ui->portsLineEdit->setValidator(portsValidator);
m_portsLineEdit->setValidator(portsValidator);
const SshParameters &sshParams = device()->sshParameters();
switch (sshParams.authenticationType) {
case SshParameters::AuthenticationTypeSpecificKey:
m_ui->keyButton->setChecked(true);
m_keyButton->setChecked(true);
break;
case SshParameters::AuthenticationTypeAll:
m_ui->defaultAuthButton->setChecked(true);
m_defaultAuthButton->setChecked(true);
break;
}
m_ui->timeoutSpinBox->setValue(sshParams.timeout);
m_ui->hostLineEdit->setEnabled(!device()->isAutoDetected());
m_ui->sshPortSpinBox->setEnabled(!device()->isAutoDetected());
m_ui->hostKeyCheckBox->setChecked(sshParams.hostKeyCheckingMode != SshHostKeyCheckingNone);
m_timeoutSpinBox->setValue(sshParams.timeout);
m_hostLineEdit->setEnabled(!device()->isAutoDetected());
m_sshPortSpinBox->setEnabled(!device()->isAutoDetected());
m_hostKeyCheckBox->setChecked(sshParams.hostKeyCheckingMode != SshHostKeyCheckingNone);
m_ui->hostLineEdit->setText(sshParams.host());
m_ui->sshPortSpinBox->setValue(sshParams.port());
m_ui->portsLineEdit->setText(device()->freePorts().toString());
m_ui->timeoutSpinBox->setValue(sshParams.timeout);
m_ui->userLineEdit->setText(sshParams.userName());
m_ui->keyFileLineEdit->setFilePath(sshParams.privateKeyFile);
m_hostLineEdit->setText(sshParams.host());
m_sshPortSpinBox->setValue(sshParams.port());
m_portsLineEdit->setText(device()->freePorts().toString());
m_timeoutSpinBox->setValue(sshParams.timeout);
m_userLineEdit->setText(sshParams.userName());
m_keyFileLineEdit->setFilePath(sshParams.privateKeyFile);
// FIXME: Use a remote executable line edit
m_ui->gdbServerLineEdit->setText(device()->debugServerPath().path());
m_gdbServerLineEdit->setText(device()->debugServerPath().path());
updatePortsWarningLabel();
}
} // RemoteLinux::Internal