QGCParamWidget.cc 18.7 KB
Newer Older
1 2 3 4
/*=====================================================================

QGroundControl Open Source Ground Control Station

pixhawk's avatar
pixhawk committed
5
(c) 2009, 2010 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

This file is part of the QGROUNDCONTROL project

    QGROUNDCONTROL is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    QGROUNDCONTROL is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.

======================================================================*/
/**
 * @file
 *   @brief Implementation of class QGCParamWidget
 *   @author Lorenz Meier <mail@qgroundcontrol.org>
 */
Lorenz Meier's avatar
Lorenz Meier committed
28 29
#include <cmath>
#include <float.h>
tstellanova's avatar
tstellanova committed
30 31
#include <QApplication>
#include <QDebug>
32
#include <QFile>
tstellanova's avatar
tstellanova committed
33 34
#include <QGridLayout>

35
#include <QList>
tstellanova's avatar
tstellanova committed
36 37 38
#include <QPushButton>
#include <QSettings>
#include <QTime>
pixhawk's avatar
pixhawk committed
39

Lorenz Meier's avatar
Lorenz Meier committed
40
#include "MainWindow.h"
41
#include "QGC.h"
tstellanova's avatar
tstellanova committed
42 43 44
#include "QGCParamWidget.h"
#include "UASInterface.h"
#include "UASParameterCommsMgr.h"
pixhawk's avatar
pixhawk committed
45

46 47 48 49
/**
 * @param uas MAV to set the parameters on
 * @param parent Parent widget
 */
50 51
QGCParamWidget::QGCParamWidget(QWidget *parent) :
    QGCBaseParamWidget(parent),
52 53 54
    componentItems(new QMap<int, QTreeWidgetItem*>()),
    statusLabel(new QLabel(this)),
    tree(new QTreeWidget(this))
pixhawk's avatar
pixhawk committed
55
{
lm's avatar
lm committed
56

57

58 59 60
}


61

62 63 64 65
void QGCParamWidget::disconnectViewSignalsAndSlots()
{
    disconnect(tree, SIGNAL(itemChanged(QTreeWidgetItem*,int)),
            this, SLOT(parameterItemChanged(QTreeWidgetItem*,int)));
66
}
67 68


69 70
void QGCParamWidget::connectViewSignalsAndSlots()
{
71 72 73 74 75
    // Listen for edits to the tree UI
    connect(tree, SIGNAL(itemChanged(QTreeWidgetItem*,int)),
            this, SLOT(parameterItemChanged(QTreeWidgetItem*,int)));
}

76

77
void QGCParamWidget::addActionButtonsToLayout(QGridLayout* layout)
78
{
Jessica's avatar
Jessica committed
79
    QPushButton* refreshButton = new QPushButton(tr("Get"));
80 81
    refreshButton->setToolTip(tr("Fetch parameters currently in volatile memory of aircraft."));
    refreshButton->setWhatsThis(tr("Fetch parameters currently in volatile memory of aircraft."));
82 83
    connect(refreshButton, SIGNAL(clicked()),
            this, SLOT(requestOnboardParamsUpdate()));
84
    layout->addWidget(refreshButton, 2, 0);
85

Jessica's avatar
Jessica committed
86
    QPushButton* setButton = new QPushButton(tr("Set"));
87 88
    setButton->setToolTip(tr("Send pending parameters to volatile onboard memory"));
    setButton->setWhatsThis(tr("Send pending parameters to volatile onboard memory"));
tstellanova's avatar
tstellanova committed
89
    connect(setButton, SIGNAL(clicked()),
90
            paramMgr, SLOT(sendPendingParameters()));
91
    layout->addWidget(setButton, 2, 1);
92

93
    QPushButton* writeButton = new QPushButton(tr("Write (ROM)"));
94 95
    writeButton->setToolTip(tr("Copy parameters in volatile memory of the aircraft to persistent memory. Transmit your parameters first to write these."));
    writeButton->setWhatsThis(tr("Copy parameters in volatile memory of the aircraft to persistent memory. Transmit your parameters first to write these."));
96 97
    connect(writeButton, SIGNAL(clicked()),
            paramMgr, SLOT(copyVolatileParamsToPersistent()));
98
    layout->addWidget(writeButton, 2, 2);
99

100
    QPushButton* loadFileButton = new QPushButton(tr("Load File"));
101 102
    loadFileButton->setToolTip(tr("Load parameters from a file into qgroundcontrol. To write these to the aircraft, use transmit after loading them."));
    loadFileButton->setWhatsThis(tr("Load parameters from a file into qgroundcontrol. To write these to the aircraft, use transmit after loading them."));
103 104
    connect(loadFileButton, SIGNAL(clicked()),
            this, SLOT(loadParametersFromFile()));
105
    layout->addWidget(loadFileButton, 3, 0);
106 107

    QPushButton* saveFileButton = new QPushButton(tr("Save File"));
108 109
    saveFileButton->setToolTip(tr("Save parameters in this view to a file on this computer."));
    saveFileButton->setWhatsThis(tr("Save parameters in this view to a file on this computer."));
110 111
    connect(saveFileButton, SIGNAL(clicked()),
            this, SLOT(saveParametersToFile()));
112
    layout->addWidget(saveFileButton, 3, 1);
lm's avatar
lm committed
113 114

    QPushButton* readButton = new QPushButton(tr("Read (ROM)"));
115 116
    readButton->setToolTip(tr("Copy parameters from persistent onboard memory to volatile onboard memory of aircraft. DOES NOT update the parameters in this view: click refresh after copying them to get them."));
    readButton->setWhatsThis(tr("Copy parameters from persistent onboard memory to volatile onboard memory of aircraft. DOES NOT update the parameters in this view: click refresh after copying them to get them."));
117 118
    connect(readButton, SIGNAL(clicked()),
            paramMgr, SLOT(copyPersistentParamsToVolatile()));
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
    layout->addWidget(readButton, 3, 2);

}

void QGCParamWidget::layoutWidget()
{

    statusLabel->setAutoFillBackground(true);

    QGridLayout* layout = new QGridLayout(this);
    layout->setHorizontalSpacing(6);
    layout->setVerticalSpacing(6);
    layout->setMargin(0);
    layout->setSizeConstraint(QLayout::SetMinimumSize);

    // Parameter tree
    layout->addWidget(tree, 0, 0, 1, 3);

    // Status line
    statusLabel->setText(tr("Click refresh to download parameters"));
    layout->addWidget(statusLabel, 1, 0, 1, 3);

    // BUTTONS
    addActionButtonsToLayout(layout);
143

144
    // Set correct vertical scaling
145 146 147 148
    layout->setRowStretch(0, 100);
    layout->setRowStretch(1, 10);
    layout->setRowStretch(2, 10);
    layout->setRowStretch(3, 10);
149

150
    // Set layout
151
    this->setLayout(layout);
pixhawk's avatar
pixhawk committed
152 153 154 155 156 157 158

    // Set header
    QStringList headerItems;
    headerItems.append("Parameter");
    headerItems.append("Value");
    tree->setHeaderLabels(headerItems);
    tree->setColumnCount(2);
tstellanova's avatar
tstellanova committed
159
    tree->setColumnWidth(0,200);
160
    tree->setColumnWidth(1,120);
161
    tree->setExpandsOnDoubleClick(true);
162

163
    tree->setVisible(true);
pixhawk's avatar
pixhawk committed
164 165
}

tstellanova's avatar
tstellanova committed
166

tstellanova's avatar
tstellanova committed
167
void QGCParamWidget::addComponentItem(int compId, QString compName)
pixhawk's avatar
pixhawk committed
168
{
tstellanova's avatar
tstellanova committed
169

170 171
    QString compLine = QString("%1 (#%2)").arg(compName).arg(compId);

172 173
    //QString ptrStr = QString().sprintf("%8p", this);
    //qDebug() <<  "QGCParamWidget" << ptrStr << "addComponentItem:" << compLine;
174

tstellanova's avatar
tstellanova committed
175
    if (componentItems->contains(compId)) {
176 177
        // Update existing component item
        componentItems->value(compId)->setData(0, Qt::DisplayRole, compLine);
178
        //components->value(component)->setData(1, Qt::DisplayRole, QString::number(component));
tstellanova's avatar
tstellanova committed
179
        componentItems->value(compId)->setFirstColumnSpanned(true);
180
    } else {
181 182 183 184 185 186
        // Add new component item
        QStringList list(compLine);
        QTreeWidgetItem* compItem = new QTreeWidgetItem(list);
        compItem->setFirstColumnSpanned(true);
        componentItems->insert(compId, compItem);
        // Create parameter grouping for this component and update maps
tstellanova's avatar
tstellanova committed
187
        paramGroups.insert(compId, new QMap<QString, QTreeWidgetItem*>());
188
        tree->addTopLevelItem(compItem);
pixhawk's avatar
pixhawk committed
189 190
        tree->update();
    }
191

pixhawk's avatar
pixhawk committed
192 193
}

194 195
void QGCParamWidget::handlePendingParamUpdate(int compId, const QString& paramName, QVariant value, bool isPending)
{
196
    //qDebug() << "handlePendingParamUpdate:" << paramName << "with updatingParamNameLock:" << updatingParamNameLock;
197

198
    if (updatingParamNameLock == paramName) {
199
        //qDebug() << "ignoring bounce from " << paramName;
200 201 202 203
        return;
    }
    else {
        updatingParamNameLock = paramName;
204 205
    }

206
    QTreeWidgetItem* paramItem = updateParameterDisplay(compId,paramName,value);
Don Gagne's avatar
Don Gagne committed
207 208 209 210 211 212 213 214 215 216 217
    if (paramItem) {
        if (isPending) {
            paramItem->setBackground(0, QBrush(QColor(QGC::colorOrange)));
            paramItem->setBackground(1, QBrush(QColor(QGC::colorOrange)));
            //ensure that the adjusted item is visible
            tree->expandItem(paramItem->parent());
        }
        else {
            paramItem->setBackground(0, Qt::NoBrush);
            paramItem->setBackground(1, Qt::NoBrush);
        }
218 219
    }

220 221
    updatingParamNameLock.clear();

222
}
tstellanova's avatar
tstellanova committed
223

224
void QGCParamWidget::handleOnboardParamUpdate(int compId, const QString& paramName, QVariant value)
lm's avatar
lm committed
225
{
226
    //qDebug() << "handlePendingParamUpdate:" << paramName << "with updatingParamNameLock:" << updatingParamNameLock;
227
    if (paramName == updatingParamNameLock) {
228
        //qDebug() << "handlePendingParamUpdate ignoring bounce from " << paramName;
229 230
        return;
    }
231
    updatingParamNameLock = paramName;
232
    updateParameterDisplay(compId, paramName, value);
233
    updatingParamNameLock.clear();
tstellanova's avatar
tstellanova committed
234
}
235

236

237
void QGCParamWidget::handleOnboardParameterListUpToDate()
tstellanova's avatar
tstellanova committed
238
{
239 240
    //turn off updates while we refresh the entire list
    tree->setUpdatesEnabled(false);
241
    qDebug() << "WARN: LIST UPDATE";
242 243 244

    //rewrite the component item tree after receiving the full list
    QMap<int, QMap<QString, QVariant>*>::iterator i;
245
    QMap<int, QMap<QString, QVariant>*>* onboardParams = paramMgr->dataModel()->getAllOnboardParams();
246 247 248 249 250 251

    for (i = onboardParams->begin(); i != onboardParams->end(); ++i) {
        int compId = i.key();
        QMap<QString, QVariant>* paramPairs = onboardParams->value(compId);
        QMap<QString, QVariant>::iterator j;
        for (j = paramPairs->begin(); j != paramPairs->end(); j++) {
252
            updatingParamNameLock = j.key();
253
            updateParameterDisplay(compId, j.key(),j.value());
254
            updatingParamNameLock.clear();
255 256 257
        }
    }

tstellanova's avatar
tstellanova committed
258 259
    // Expand visual tree
    tree->expandItem(tree->topLevelItem(0));
260 261 262
    tree->setUpdatesEnabled(true);
    tree->update();

lm's avatar
lm committed
263 264
}

265
QTreeWidgetItem* QGCParamWidget::findChildWidgetItemForParam(QTreeWidgetItem* parentItem, const QString& paramName)
tstellanova's avatar
tstellanova committed
266
{
267 268 269 270 271 272 273 274 275
    QTreeWidgetItem* childItem = NULL;

    for (int i = 0; i < parentItem->childCount(); i++) {
        QTreeWidgetItem* child = parentItem->child(i);
        QString key = child->data(0, Qt::DisplayRole).toString();
        if (key == paramName)  {
            childItem = child;
            break;
        }
pixhawk's avatar
pixhawk committed
276
    }
277

278 279 280 281 282
    return childItem;
}

QTreeWidgetItem* QGCParamWidget::getParentWidgetItemForParam(int compId, const QString& paramName)
{
283 284
    QTreeWidgetItem* parentItem = componentItems->value(compId);

pixhawk's avatar
pixhawk committed
285 286
    QString splitToken = "_";
    // Check if auto-grouping can work
287 288
    if (paramName.contains(splitToken)) {
        QString parentStr = paramName.section(splitToken, 0, 0, QString::SectionSkipEmpty);
tstellanova's avatar
tstellanova committed
289 290
        QMap<QString, QTreeWidgetItem*>* compParamGroups = paramGroups.value(compId);
        if (!compParamGroups->contains(parentStr)) {
pixhawk's avatar
pixhawk committed
291 292
            // Insert group item
            QStringList glist;
tstellanova's avatar
tstellanova committed
293
            glist.append(parentStr);
294
            QTreeWidgetItem* groupItem = new QTreeWidgetItem(glist);
tstellanova's avatar
tstellanova committed
295 296 297 298 299 300 301

            compParamGroups->insert(parentStr, groupItem);

            // insert new group alphabetized
            QList<QString> groupKeys = compParamGroups->uniqueKeys();
            int insertIdx = groupKeys.indexOf(parentStr);
            componentItems->value(compId)->insertChild(insertIdx,groupItem);
302
        }
303

304
        //parent item for this parameter item will be a group widget item
305 306 307
        parentItem = compParamGroups->value(parentStr);
    }
    else  {
308
        //parent item for this parameter will be the top level (component) widget item
309 310 311
        parentItem = componentItems->value(compId);
    }

312 313
    return parentItem;
}
314

315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
void QGCParamWidget::insertParamAlphabetical(int indexLowerBound, int indexUpperBound, QTreeWidgetItem* parentItem, QTreeWidgetItem* paramItem)
{
    if (indexLowerBound >= indexUpperBound)
    {
        if (paramItem->text(0).compare(parentItem->child(indexLowerBound)->text(0)) < 0) {
            parentItem->insertChild(indexLowerBound, paramItem);
        }
        else
        {
            if (indexLowerBound < parentItem->childCount() - 1) {
                parentItem->insertChild(indexLowerBound + 1, paramItem);
            }
            else
            {
                parentItem->addChild(paramItem);
            }
        }
    }
    else
    {
Don Gagne's avatar
Don Gagne committed
335
        int midpoint = indexLowerBound + ((indexUpperBound - indexLowerBound) / 2);
336 337 338 339 340 341 342 343 344 345 346 347

        if (paramItem->text(0).compare(parentItem->child(midpoint)->text(0)) < 0)
        {
            insertParamAlphabetical(indexLowerBound, midpoint - 1, parentItem, paramItem);
        } else
        {
            insertParamAlphabetical(midpoint + 1, indexUpperBound, parentItem, paramItem);
        }

    }
}

348 349
QTreeWidgetItem* QGCParamWidget::updateParameterDisplay(int compId, QString parameterName, QVariant value)
{
350
    //qDebug() << "QGCParamWidget::updateParameterDisplay" << parameterName;
Don Gagne's avatar
Don Gagne committed
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
    
    // Filter the parameters according to the filter list
    if (_filterList.count() != 0) {
        bool filterFound = false;
        foreach(QString paramFilter, _filterList) {
            if (paramFilter.endsWith("*") && parameterName.startsWith(paramFilter.left(paramFilter.size() - 1))) {
                filterFound = true;
                break;
            }
            if (paramFilter == parameterName) {
                filterFound = true;
                break;            
            }
        }
        if (!filterFound) {
            return NULL;
        }
    }
369 370

    // Reference to item in tree
371
    QTreeWidgetItem* paramItem = NULL;
372 373 374 375 376 377 378 379 380 381

    // Add component item if necessary
    if (!componentItems->contains(compId)) {
        QString componentName = tr("Component #%1").arg(compId);
        addComponentItem(compId, componentName);
    }

    //default parent item for this parameter widget item will be the top level component item
    QTreeWidgetItem* parentItem = getParentWidgetItemForParam(compId,parameterName);
    if (parentItem) {
382 383
        paramItem = findChildWidgetItemForParam(parentItem,parameterName);
        if (!paramItem) {
384 385 386
            // Insert parameter into map
            QStringList plist;
            plist.append(parameterName);
387
            // CREATE PARAMETER ITEM
388
            paramItem = new QTreeWidgetItem(plist);
389
            // CONFIGURE PARAMETER ITEM
tstellanova's avatar
tstellanova committed
390
            if (value.type() == QVariant::Char) {
391
                paramItem->setData(1, Qt::DisplayRole, value.toUInt());
392
            }
tstellanova's avatar
tstellanova committed
393
            else {
394
                paramItem->setData(1, Qt::DisplayRole, value);
395
            }
396
            paramItem->setFlags(paramItem->flags() | Qt::ItemIsEditable);
397

398
            //Insert alphabetically
399 400 401
            if (parentItem->childCount() > 0) {
                insertParamAlphabetical(0, parentItem->childCount() - 1, parentItem, paramItem);
            } else
402 403 404
            {
                parentItem->addChild(paramItem);
            }
405 406

            //only add the tooltip when the parameter item is first added
407
            QString paramDesc = paramMgr->dataModel()->getParamDescription(parameterName);
408 409
            if (!paramDesc.isEmpty()) {
                QString tooltipFormat;
410
                if (paramMgr->dataModel()->isParamDefaultKnown(parameterName)) {
411
                    tooltipFormat = tr("Default: %1, %2");
412
                    double paramDefValue = paramMgr->dataModel()->getParamDefault(parameterName);
413 414 415 416 417
                    tooltipFormat = tooltipFormat.arg(paramDefValue).arg(paramDesc);
                }
                else {
                    tooltipFormat = paramDesc;
                }
418 419
                paramItem->setToolTip(0, tooltipFormat);
                paramItem->setToolTip(1, tooltipFormat);
420 421 422
            }
        }

423
        //update the parameterItem's data
424
        if (value.type() == QVariant::Char) {
425
            paramItem->setData(1, Qt::DisplayRole, value.toUInt());
426 427
        }
        else {
428
            paramItem->setData(1, Qt::DisplayRole, value);
pixhawk's avatar
pixhawk committed
429
        }
430

431
    }
432

433
    if (paramItem) {
434
        // Reset background color
435 436
        paramItem->setBackground(0, Qt::NoBrush);
        paramItem->setBackground(1, Qt::NoBrush);
437

438 439 440 441 442 443 444
        paramItem->setTextColor(0, QGC::colorDarkWhite);
        paramItem->setTextColor(1, QGC::colorDarkWhite);

        if (paramItem == tree->currentItem()) {
            //need to unset current item to clear highlighting (green by default)
            tree->setCurrentItem(NULL); //clear the selected line
        }
445

446
    }
447

448
    return paramItem;
pixhawk's avatar
pixhawk committed
449 450
}

lm's avatar
lm committed
451

452

453
void QGCParamWidget::parameterItemChanged(QTreeWidgetItem* paramItem, int column)
lm's avatar
lm committed
454
{
455
    if (paramItem && column > 0) {
456

457
        QString key = paramItem->data(0, Qt::DisplayRole).toString();
458
        //qDebug() << "parameterItemChanged:" << key << "with updatingParamNameLock:" << updatingParamNameLock;
459 460

        if (key == updatingParamNameLock) {
461
            //qDebug() << "parameterItemChanged ignoring bounce from " << key;
462 463
            return;
        }
464 465 466
        else {
            updatingParamNameLock = key;
        }
467 468

        QTreeWidgetItem* parent = paramItem->parent();
469
        while (parent->parent() != NULL) {
470 471 472
            parent = parent->parent();
        }
        // Parent is now top-level component
473
        int componentId = componentItems->key(parent);
474
        QVariant value = paramItem->data(1, Qt::DisplayRole);
475

476

477
        bool pending = paramMgr->dataModel()->updatePendingParamWithValue(componentId,key,value);
478

479 480
        // If the value will result in an update
        if (pending) {
481
            // Set parameter on changed list to be transmitted to MAV
482
            statusLabel->setText(tr("Pending: %1:%2: %3").arg(componentId).arg(key).arg(value.toFloat(), 5, 'f', 1, QChar(' ')));
483

484 485
            paramItem->setBackground(0, QBrush(QColor(QGC::colorOrange)));
            paramItem->setBackground(1, QBrush(QColor(QGC::colorOrange)));
486
        }
487
        else {
488
            QMap<QString , QVariant>* pendingParams = paramMgr->dataModel()->getPendingParamsForComponent(componentId);
489 490
            int pendingCount = pendingParams->count();
            statusLabel->setText(tr("Pending items: %1").arg(pendingCount));
491 492
            paramItem->setBackground(0, Qt::NoBrush);
            paramItem->setBackground(1, Qt::NoBrush);
493
        }
494

495 496 497 498 499 500

        if (paramItem == tree->currentItem()) {
            //need to unset current item to clear highlighting (green by default)
            tree->setCurrentItem(NULL); //clear the selected line
        }

501
        updatingParamNameLock.clear();
502 503 504
    }
}

505

tstellanova's avatar
tstellanova committed
506
void QGCParamWidget::setParameterStatusMsg(const QString& msg)
507
{
tstellanova's avatar
tstellanova committed
508 509 510
    statusLabel->setText(msg);
}

511

512
void QGCParamWidget::clearOnboardParamDisplay()
513
{
514 515
    tree->clear();
    componentItems->clear();
516 517
}

518
void QGCParamWidget::clearPendingParamDisplay()
pixhawk's avatar
pixhawk committed
519 520
{
    tree->clear();
521
    componentItems->clear();
pixhawk's avatar
pixhawk committed
522
}
tstellanova's avatar
tstellanova committed
523

524

tstellanova's avatar
tstellanova committed
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
void QGCParamWidget::handleParamStatusMsgUpdate(QString msg, int level)
{
    QColor bgColor = QGC::colorGreen;
    if ((int)UASParameterCommsMgr::ParamCommsStatusLevel_Warning == level) {
        bgColor = QGC::colorOrange;
    }
    else if ((int)UASParameterCommsMgr::ParamCommsStatusLevel_Error == level) {
        bgColor =  QGC::colorRed;
    }

    QPalette pal = statusLabel->palette();
    pal.setColor(backgroundRole(), bgColor);
    statusLabel->setPalette(pal);
    statusLabel->setText(msg);
}