QGCParamSlider.cc 18.8 KB
Newer Older
1 2
#include <QMenu>
#include <QContextMenuEvent>
3
#include <QSettings>
4
#include <QTimer>
Lorenz Meier's avatar
Lorenz Meier committed
5
#include <QToolTip>
6

7 8
#include "QGCParamSlider.h"
#include "ui_QGCParamSlider.h"
9
#include "UASInterface.h"
10
#include "UASManager.h"
11

12

13
QGCParamSlider::QGCParamSlider(QWidget *parent) :
14 15 16 17 18 19
    QGCToolWidgetItem("Slider", parent),
    parameterName(""),
    parameterValue(0.0f),
    parameterScalingFactor(0.0),
    parameterMin(0.0f),
    parameterMax(0.0f),
20
    componentId(0),
21 22
    ui(new Ui::QGCParamSlider)
{
23
    valueModLock = false;
24
    visibleEnabled = true;
25
    valueModLockParam = false;
26
    ui->setupUi(this);
27
    ui->intValueSpinBox->hide();
28 29
    ui->valueSlider->setEnabled(false);
    ui->doubleValueSpinBox->setEnabled(false);
30
    uas = NULL;
pixhawk's avatar
pixhawk committed
31 32 33

    scaledInt = ui->valueSlider->maximum() - ui->valueSlider->minimum();

34
    ui->editInfoCheckBox->hide();
35 36 37 38 39 40 41 42
    ui->editDoneButton->hide();
    ui->editNameLabel->hide();
    ui->editRefreshParamsButton->hide();
    ui->editSelectParamComboBox->hide();
    ui->editSelectComponentComboBox->hide();
    ui->editStatusLabel->hide();
    ui->editMinSpinBox->hide();
    ui->editMaxSpinBox->hide();
43 44
    ui->editLine1->hide();
    ui->editLine2->hide();
45
    ui->infoLabel->hide();
46

pixhawk's avatar
pixhawk committed
47
    connect(ui->editDoneButton, SIGNAL(clicked()), this, SLOT(endEditMode()));
48 49

    // Sending actions
50 51 52 53 54 55 56 57 58 59 60 61 62 63
    connect(ui->writeButton, SIGNAL(clicked()),
            this, SLOT(setParamPending()));
    connect(ui->editSelectComponentComboBox, SIGNAL(currentIndexChanged(int)),
            this, SLOT(selectComponent(int)));
    connect(ui->editSelectParamComboBox, SIGNAL(currentIndexChanged(int)),
            this, SLOT(selectParameter(int)));
    connect(ui->valueSlider, SIGNAL(valueChanged(int)),
            this, SLOT(setSliderValue(int)));
    connect(ui->doubleValueSpinBox, SIGNAL(valueChanged(double)),
            this, SLOT(setParamValue(double)));
    connect(ui->intValueSpinBox, SIGNAL(valueChanged(int)),
            this, SLOT(setParamValue(int)));
    connect(ui->editNameLabel, SIGNAL(textChanged(QString)),
            ui->nameLabel, SLOT(setText(QString)));
64
    connect(ui->readButton, SIGNAL(clicked()), this, SLOT(requestParameter()));
65 66 67 68
    connect(ui->editRefreshParamsButton, SIGNAL(clicked()),
            this, SLOT(refreshParamList()));
    connect(ui->editInfoCheckBox, SIGNAL(clicked(bool)),
            this, SLOT(showInfo(bool)));
Lorenz Meier's avatar
Lorenz Meier committed
69
    // connect to self
70 71
    connect(ui->infoLabel, SIGNAL(released()),
            this, SLOT(showTooltip()));
72 73 74

    init();
    requestParameter();
75 76 77 78 79 80 81
}

QGCParamSlider::~QGCParamSlider()
{
    delete ui;
}

Lorenz Meier's avatar
Lorenz Meier committed
82 83 84 85 86 87
void QGCParamSlider::showTooltip()
{
    QWidget* sender = dynamic_cast<QWidget*>(QObject::sender());

    if (sender)
    {
88
        QPoint point = mapToGlobal(ui->infoLabel->pos());
Lorenz Meier's avatar
Lorenz Meier committed
89 90 91 92
        QToolTip::showText(point, sender->toolTip());
    }
}

93 94 95 96
void QGCParamSlider::refreshParamList()
{
    ui->editSelectParamComboBox->setEnabled(true);
    ui->editSelectComponentComboBox->setEnabled(true);
97
    if (uas) {
98
        uas->getParamManager()->requestParameterList();
Lorenz Meier's avatar
Lorenz Meier committed
99
        ui->editStatusLabel->setText(tr("Parameter list updating.."));
100 101 102
    }
}

103 104
void QGCParamSlider::setActiveUAS(UASInterface* activeUas)
{
105

106 107 108 109
    if (uas != activeUas)  {
        if (uas) {
            disconnect(uas, SIGNAL(parameterChanged(int,int,int,int,QString,QVariant)),
                       this, SLOT(setParameterValue(int,int,int,int,QString,QVariant)));
110
        }
111 112 113
        if (activeUas) {
            connect(activeUas, SIGNAL(parameterChanged(int,int,int,int,QString,QVariant)),
                    this, SLOT(setParameterValue(int,int,int,int,QString,QVariant)), Qt::UniqueConnection);
114
        }
115
        uas = activeUas;
116
    }
117 118

    if (uas && !parameterName.isEmpty()) {
119
        QString text =  uas->getParamManager()->dataModel()->getParamDescription(parameterName);
120 121 122 123 124 125 126 127 128 129 130
        if (!text.isEmpty()) {
            ui->infoLabel->setToolTip(text);
            ui->infoLabel->show();
        }
        // Force-uncheck and hide label if no description is available
        if (ui->editInfoCheckBox->isChecked()) {
            showInfo((text.length() > 0));
        }
    }


131 132 133 134
}

void QGCParamSlider::requestParameter()
{
135
    if (uas && !parameterName.isEmpty()) {
136
        uas->getParamManager()->requestParameterUpdate(componentId, parameterName);
137 138 139
    }
}

140 141 142 143 144 145
void QGCParamSlider::showInfo(bool enable)
{
    ui->editInfoCheckBox->setChecked(enable);
    ui->infoLabel->setVisible(enable);
}

146 147
void QGCParamSlider::setParamValue(double value)
{
148
    parameterValue = (float)value;
149 150 151 152 153 154 155 156 157 158 159
     //disconnect(ui->valueSlider,SIGNAL(valueChanged(int)));
    if (!valueModLock && !valueModLockParam)
    {
        valueModLock = true;
        ui->valueSlider->setValue(floatToScaledInt(value));
    }
    else
    {
        valueModLock = false;
    }
    //connect(ui->valueSlider, SIGNAL(valueChanged(int)), this, SLOT(setSliderValue(int)));
160 161
}

162 163 164
void QGCParamSlider::setParamValue(int value)
{
    parameterValue = value;
165 166 167 168 169 170 171 172 173 174 175
    // disconnect(ui->valueSlider,SIGNAL(valueChanged(int)));
    if (!valueModLock && !valueModLockParam)
    {
        valueModLock = true;
        ui->valueSlider->setValue(floatToScaledInt(value));
    }
    else
    {
        valueModLock = false;
    }
    //connect(ui->valueSlider, SIGNAL(valueChanged(int)), this, SLOT(setSliderValue(int)));
176 177
}

178 179
void QGCParamSlider::selectComponent(int componentIndex)
{
180
    this->componentId = ui->editSelectComponentComboBox->itemData(componentIndex).toInt();
181 182 183 184
}

void QGCParamSlider::selectParameter(int paramIndex)
{
LM's avatar
LM committed
185
    // Set name
186
    parameterName = ui->editSelectParamComboBox->itemText(paramIndex);
tstellanova's avatar
tstellanova committed
187 188 189
    if (parameterName.isEmpty()) {
        return;
    }
LM's avatar
LM committed
190 191

    // Update min and max values if available
192
    if (uas) {
193
        UASParameterDataModel* dataModel =  uas->getParamManager()->dataModel();
194
        if (dataModel) {
LM's avatar
LM committed
195
            // Minimum
196 197
            if (dataModel->isParamMinKnown(parameterName)) {
                parameterMin = dataModel->getParamMin(parameterName);
LM's avatar
LM committed
198 199 200 201
                ui->editMinSpinBox->setValue(parameterMin);
            }

            // Maximum
202 203
            if (dataModel->isParamMaxKnown(parameterName)) {
                parameterMax = dataModel->getParamMax(parameterName);
LM's avatar
LM committed
204 205 206 207
                ui->editMaxSpinBox->setValue(parameterMax);
            }
        }
    }
208 209
}

210
void QGCParamSlider::setEditMode(bool editMode)
211
{
212 213 214
    if(!editMode) {
        // Store component id
        selectComponent(ui->editSelectComponentComboBox->currentIndex());
215

216 217
        // Store parameter name and id
        selectParameter(ui->editSelectParamComboBox->currentIndex());
218

219 220 221
        // Min/max
        parameterMin = ui->editMinSpinBox->value();
        parameterMax = ui->editMaxSpinBox->value();
222

223 224
        requestParameter();

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241
        switch ((int)parameterValue.type())
        {
        case QVariant::Char:
        case QVariant::Int:
        case QVariant::UInt:
            ui->intValueSpinBox->show();
            break;
        case QMetaType::Float:
            ui->doubleValueSpinBox->show();
            break;
        default:
            qCritical() << "ERROR: NO VALID PARAM TYPE";
            return;
        }
    } else {
        ui->doubleValueSpinBox->hide();
        ui->intValueSpinBox->hide();
242
    }
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
    ui->valueSlider->setVisible(!editMode);
    ui->nameLabel->setVisible(!editMode);
    ui->writeButton->setVisible(!editMode);
    ui->readButton->setVisible(!editMode);

    ui->editInfoCheckBox->setVisible(editMode);
    ui->editDoneButton->setVisible(editMode);
    ui->editNameLabel->setVisible(editMode);
    ui->editRefreshParamsButton->setVisible(editMode);
    ui->editSelectParamComboBox->setVisible(editMode);
    ui->editSelectComponentComboBox->setVisible(editMode);
    ui->editStatusLabel->setVisible(editMode);
    ui->editMinSpinBox->setVisible(editMode);
    ui->editMaxSpinBox->setVisible(editMode);
    ui->writeButton->setVisible(!editMode);
    ui->readButton->setVisible(!editMode);
    ui->editLine1->setVisible(editMode);
    ui->editLine2->setVisible(editMode);

    QGCToolWidgetItem::setEditMode(editMode);
263 264
}

265
void QGCParamSlider::setParamPending()
266
{
267
    if (uas)  {
268
        uas->getParamManager()->setPendingParam(componentId, parameterName, parameterValue);
269
        uas->getParamManager()->sendPendingParameters(true, true);
270
    }
271 272
    else {
        qWarning() << __FILE__ << __LINE__ << "NO UAS SET, DOING NOTHING";
273 274 275
    }
}

pixhawk's avatar
pixhawk committed
276 277
void QGCParamSlider::setSliderValue(int sliderValue)
{
278
    if (!valueModLock && !valueModLockParam)
279
    {
280
        valueModLock = true;
281
        switch ((int)parameterValue.type())
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
        {
        case QVariant::Char:
            parameterValue = QVariant(QChar((unsigned char)scaledIntToFloat(sliderValue)));
            ui->intValueSpinBox->setValue(parameterValue.toInt());
            break;
        case QVariant::Int:
            parameterValue = (int)scaledIntToFloat(sliderValue);
            ui->intValueSpinBox->setValue(parameterValue.toInt());
            break;
        case QVariant::UInt:
            parameterValue = (unsigned int)scaledIntToFloat(sliderValue);
            ui->intValueSpinBox->setValue(parameterValue.toUInt());
            break;
        case QMetaType::Float:
            parameterValue = scaledIntToFloat(sliderValue);
            ui->doubleValueSpinBox->setValue(parameterValue.toFloat());
            break;
        default:
            qCritical() << "ERROR: NO VALID PARAM TYPE";
            valueModLock = false;
            return;
        }
    }
    else
    {
        valueModLock = false;
308
    }
pixhawk's avatar
pixhawk committed
309 310
}

311 312 313 314 315 316
/**
 * @brief uas Unmanned system sending the parameter
 * @brief component UAS component sending the parameter
 * @brief parameterName Key/name of the parameter
 * @brief value Value of the parameter
 */
317
void QGCParamSlider::setParameterValue(int uasId, int compId, int paramCount, int paramIndex, QString paramName, QVariant value)
pixhawk's avatar
pixhawk committed
318
{
319
    Q_UNUSED(paramCount);
320 321 322 323 324 325
    if (uasId != this->uas->getUASID()) {
        return;
    }

    if (ui->nameLabel->text() == "Name")  {
        ui->nameLabel->setText(paramName);
326
    }
327 328
    // Check if this component and parameter are part of the list
    bool found = false;
329 330
    for (int i = 0; i< ui->editSelectComponentComboBox->count(); ++i) {
        if (compId == ui->editSelectComponentComboBox->itemData(i).toInt()) {
331 332 333 334
            found = true;
        }
    }

335 336
    if (!found) {
        ui->editSelectComponentComboBox->addItem(tr("Component #%1").arg(compId), compId);
337 338 339 340
    }

    // Parameter checking
    found = false;
341 342
    for (int i = 0; i < ui->editSelectParamComboBox->count(); ++i) {
        if (paramName == ui->editSelectParamComboBox->itemText(i))  {
343 344 345 346
            found = true;
        }
    }

347 348
    if (!found) {
        ui->editSelectParamComboBox->addItem(paramName, paramIndex);
349 350
    }

351 352 353 354
    if (visibleParam != "") {
        if (paramName == visibleParam)  {
            if (visibleVal == value.toInt())  {
                uas->getParamManager()->requestParameterUpdate(compId,paramName);
355 356 357
                visibleEnabled = true;
                this->show();
            }
358
            else  {
359 360 361 362 363 364 365 366 367
                //Disable the component here.
                ui->valueSlider->setEnabled(false);
                ui->intValueSpinBox->setEnabled(false);
                ui->doubleValueSpinBox->setEnabled(false);
                visibleEnabled = false;
                this->hide();
            }
        }
    }
368
    Q_UNUSED(uas);
369
    if (compId == this->componentId && paramName == this->parameterName) {
370
        if (!visibleEnabled) {
371 372
            return;
        }
373
        parameterValue = value;
374
        ui->valueSlider->setEnabled(true);
375
        valueModLockParam = true;
376
        switch ((int)value.type())
377
        {
378 379 380 381 382
        case QVariant::Char:
            ui->intValueSpinBox->show();
            ui->intValueSpinBox->setEnabled(true);
            ui->doubleValueSpinBox->hide();
            ui->intValueSpinBox->setValue(value.toUInt());
383
            ui->intValueSpinBox->setRange(0, UINT8_MAX);
384 385
            if (parameterMax == 0 && parameterMin == 0)
            {
386
                ui->editMaxSpinBox->setValue(UINT8_MAX);
387 388
                ui->editMinSpinBox->setValue(0);
            }
389
            ui->valueSlider->setValue(floatToScaledInt(value.toUInt()));
390
            break;
391 392
        case QVariant::Int:
            ui->intValueSpinBox->show();
393
            ui->intValueSpinBox->setEnabled(true);
394
            ui->doubleValueSpinBox->hide();
395
            ui->intValueSpinBox->setValue(value.toInt());
396
            ui->intValueSpinBox->setRange(INT32_MIN, INT32_MAX);
397 398
            if (parameterMax == 0 && parameterMin == 0)
            {
399 400
                ui->editMaxSpinBox->setValue(INT32_MAX);
                ui->editMinSpinBox->setValue(INT32_MIN);
401
            }
402
            ui->valueSlider->setValue(floatToScaledInt(value.toInt()));
403 404 405
            break;
        case QVariant::UInt:
            ui->intValueSpinBox->show();
406
            ui->intValueSpinBox->setEnabled(true);
407
            ui->doubleValueSpinBox->hide();
408
            ui->intValueSpinBox->setValue(value.toUInt());
409
            ui->intValueSpinBox->setRange(0, UINT32_MAX);
410 411
            if (parameterMax == 0 && parameterMin == 0)
            {
412
                ui->editMaxSpinBox->setValue(UINT32_MAX);
413 414
                ui->editMinSpinBox->setValue(0);
            }
415
            ui->valueSlider->setValue(floatToScaledInt(value.toUInt()));
416 417
            break;
        case QMetaType::Float:
418
            ui->doubleValueSpinBox->setValue(value.toFloat());
419
            ui->doubleValueSpinBox->show();
420
            ui->doubleValueSpinBox->setEnabled(true);
421
            ui->intValueSpinBox->hide();
422 423 424 425 426
            if (parameterMax == 0 && parameterMin == 0)
            {
                ui->editMaxSpinBox->setValue(10000);
                ui->editMinSpinBox->setValue(0);
            }
427
            ui->valueSlider->setValue(floatToScaledInt(value.toFloat()));
428 429 430
            break;
        default:
            qCritical() << "ERROR: NO VALID PARAM TYPE";
431
            valueModLockParam = false;
432 433
            return;
        }
434 435 436
        valueModLockParam = false;
        parameterMax = ui->editMaxSpinBox->value();
        parameterMin = ui->editMinSpinBox->value();
437
    }
Lorenz Meier's avatar
Lorenz Meier committed
438

439
    if (paramIndex == paramCount - 1) {
Lorenz Meier's avatar
Lorenz Meier committed
440 441
        ui->editStatusLabel->setText(tr("Complete parameter list received."));
    }
pixhawk's avatar
pixhawk committed
442 443
}

444 445 446 447 448 449 450 451 452 453 454
void QGCParamSlider::changeEvent(QEvent *e)
{
    QWidget::changeEvent(e);
    switch (e->type()) {
    case QEvent::LanguageChange:
        ui->retranslateUi(this);
        break;
    default:
        break;
    }
}
lm's avatar
lm committed
455

pixhawk's avatar
pixhawk committed
456
float QGCParamSlider::scaledIntToFloat(int sliderValue)
lm's avatar
lm committed
457
{
458
    float result = (((double)sliderValue)/(double)scaledInt)*(ui->editMaxSpinBox->value() - ui->editMinSpinBox->value());
459
    //qDebug() << "INT TO FLOAT: CONVERTED" << sliderValue << "TO" << result;
460
    return result;
pixhawk's avatar
pixhawk committed
461
}
lm's avatar
lm committed
462

pixhawk's avatar
pixhawk committed
463 464
int QGCParamSlider::floatToScaledInt(float value)
{
465
    int result = ((value - ui->editMinSpinBox->value())/(ui->editMaxSpinBox->value() - ui->editMinSpinBox->value()))*scaledInt;
466
    //qDebug() << "FLOAT TO INT: CONVERTED" << value << "TO" << result << "SCALEDINT" << scaledInt;
467
    return result;
lm's avatar
lm committed
468 469
}

pixhawk's avatar
pixhawk committed
470
void QGCParamSlider::writeSettings(QSettings& settings)
lm's avatar
lm committed
471
{
pixhawk's avatar
pixhawk committed
472 473 474
    settings.setValue("TYPE", "SLIDER");
    settings.setValue("QGC_PARAM_SLIDER_DESCRIPTION", ui->nameLabel->text());
    //settings.setValue("QGC_PARAM_SLIDER_BUTTONTEXT", ui->actionButton->text());
475
    settings.setValue("QGC_PARAM_SLIDER_PARAMID", parameterName);
476
    settings.setValue("QGC_PARAM_SLIDER_COMPONENTID", componentId);
pixhawk's avatar
pixhawk committed
477 478
    settings.setValue("QGC_PARAM_SLIDER_MIN", ui->editMinSpinBox->value());
    settings.setValue("QGC_PARAM_SLIDER_MAX", ui->editMaxSpinBox->value());
479
    settings.setValue("QGC_PARAM_SLIDER_DISPLAY_INFO", ui->editInfoCheckBox->isChecked());
pixhawk's avatar
pixhawk committed
480
    settings.sync();
lm's avatar
lm committed
481
}
482 483 484
void QGCParamSlider::readSettings(const QString& pre,const QVariantMap& settings)
{
    parameterName = settings.value(pre + "QGC_PARAM_SLIDER_PARAMID").toString();
485
    componentId = settings.value(pre + "QGC_PARAM_SLIDER_COMPONENTID").toInt();
486 487 488 489 490 491 492 493
    ui->nameLabel->setText(settings.value(pre + "QGC_PARAM_SLIDER_DESCRIPTION").toString());
    ui->editNameLabel->setText(settings.value(pre + "QGC_PARAM_SLIDER_DESCRIPTION").toString());
    //settings.setValue("QGC_PARAM_SLIDER_BUTTONTEXT", ui->actionButton->text());
    ui->editSelectParamComboBox->addItem(settings.value(pre + "QGC_PARAM_SLIDER_PARAMID").toString());
    ui->editSelectParamComboBox->setCurrentIndex(ui->editSelectParamComboBox->count()-1);
    ui->editSelectComponentComboBox->addItem(tr("Component #%1").arg(settings.value(pre + "QGC_PARAM_SLIDER_COMPONENTID").toInt()), settings.value(pre + "QGC_PARAM_SLIDER_COMPONENTID").toInt());
    ui->editMinSpinBox->setValue(settings.value(pre + "QGC_PARAM_SLIDER_MIN").toFloat());
    ui->editMaxSpinBox->setValue(settings.value(pre + "QGC_PARAM_SLIDER_MAX").toFloat());
494 495
    visibleParam = settings.value(pre+"QGC_PARAM_SLIDER_VISIBLE_PARAM","").toString();
    visibleVal = settings.value(pre+"QGC_PARAM_SLIDER_VISIBLE_VAL",0).toInt();
496 497 498 499
    parameterMax = ui->editMaxSpinBox->value();
    parameterMin = ui->editMinSpinBox->value();
    //ui->valueSlider->setMaximum(parameterMax);
    //ui->valueSlider->setMinimum(parameterMin);
500 501 502 503 504 505
    showInfo(settings.value(pre + "QGC_PARAM_SLIDER_DISPLAY_INFO", true).toBool());
    ui->editSelectParamComboBox->setEnabled(true);
    ui->editSelectComponentComboBox->setEnabled(true);

    setActiveUAS(UASManager::instance()->getActiveUAS());
}
lm's avatar
lm committed
506 507 508

void QGCParamSlider::readSettings(const QSettings& settings)
{
509 510 511 512 513 514 515 516
    QVariantMap map;
    foreach (QString key,settings.allKeys())
    {
        map[key] = settings.value(key);
    }

    readSettings("",map);
    return;
517
    parameterName = settings.value("QGC_PARAM_SLIDER_PARAMID").toString();
518
    componentId = settings.value("QGC_PARAM_SLIDER_COMPONENTID").toInt();
pixhawk's avatar
pixhawk committed
519
    ui->nameLabel->setText(settings.value("QGC_PARAM_SLIDER_DESCRIPTION").toString());
520
    ui->editNameLabel->setText(settings.value("QGC_PARAM_SLIDER_DESCRIPTION").toString());
pixhawk's avatar
pixhawk committed
521
    //settings.setValue("QGC_PARAM_SLIDER_BUTTONTEXT", ui->actionButton->text());
522 523
    ui->editSelectParamComboBox->addItem(settings.value("QGC_PARAM_SLIDER_PARAMID").toString());
    ui->editSelectParamComboBox->setCurrentIndex(ui->editSelectParamComboBox->count()-1);
524
    ui->editSelectComponentComboBox->addItem(tr("Component #%1").arg(settings.value("QGC_PARAM_SLIDER_COMPONENTID").toInt()), settings.value("QGC_PARAM_SLIDER_COMPONENTID").toInt());
525 526
    ui->editMinSpinBox->setValue(settings.value("QGC_PARAM_SLIDER_MIN").toFloat());
    ui->editMaxSpinBox->setValue(settings.value("QGC_PARAM_SLIDER_MAX").toFloat());
527 528 529
    visibleParam = settings.value("QGC_PARAM_SLIDER_VISIBLE_PARAM","").toString();
             //QGC_TOOL_WIDGET_ITEMS\1\QGC_PARAM_SLIDER_VISIBLE_PARAM=RC5_FUNCTION
    visibleVal = settings.value("QGC_PARAM_SLIDER_VISIBLE_VAL",0).toInt();
530 531
    parameterMax = ui->editMaxSpinBox->value();
    parameterMin = ui->editMinSpinBox->value();
532
    showInfo(settings.value("QGC_PARAM_SLIDER_DISPLAY_INFO", true).toBool());
533 534
    ui->editSelectParamComboBox->setEnabled(true);
    ui->editSelectComponentComboBox->setEnabled(true);
535 536 537

    setActiveUAS(UASManager::instance()->getActiveUAS());

lm's avatar
lm committed
538
}