companion/src/modeledit/setup.cpp

   1 /*
   2  * Copyright (C) OpenTX
   3  *
   4  * Based on code named
   5  *   th9x - http://code.google.com/p/th9x
   6  *   er9x - http://code.google.com/p/er9x
   7  *   gruvin9x - http://code.google.com/p/gruvin9x
   8  *
   9  * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  */
  20
  21 #include "setup.h"
  22 #include "ui_setup.h"
  23 #include "ui_setup_timer.h"
  24 #include "ui_setup_module.h"
  25 #include "switchitemmodel.h"
  26 #include "appdata.h"
  27 #include "modelprinter.h"
  28 #include "multiprotocols.h"
  29 #include "checklistdialog.h"
  30
  31 TimerPanel::TimerPanel(QWidget *parent, ModelData & model, TimerData & timer, GeneralSettings & generalSettings, Firmware * firmware, QWidget * prevFocus):
  32   ModelPanel(parent, model, generalSettings, firmware),
  33   timer(timer),
  34   ui(new Ui::Timer)
  35 {
  36   Board::Type board = firmware->getBoard();
  37
  38   ui->setupUi(this);
  39
  40   lock = true;
  41
  42   // Name
  43   int length = firmware->getCapability(TimersName);
  44   if (length == 0) {
  45     ui->name->hide();
  46   }
  47   else {
  48     ui->name->setMaxLength(length);
  49     ui->name->setText(timer.name);
  50   }
  51
  52   // Mode
  53   rawSwitchItemModel = new RawSwitchFilterItemModel(&generalSettings, &model, TimersContext);
  54   ui->mode->setModel(rawSwitchItemModel);
  55   ui->mode->setCurrentIndex(ui->mode->findData(timer.mode.toValue()));
  56
  57   if (!firmware->getCapability(PermTimers)) {
  58     ui->persistent->hide();
  59     ui->persistentValue->hide();
  60   }
  61
  62   ui->countdownBeep->setField(timer.countdownBeep, this);
  63   ui->countdownBeep->addItem(tr("Silent"), TimerData::COUNTDOWN_SILENT);
  64   ui->countdownBeep->addItem(tr("Beeps"), TimerData::COUNTDOWN_BEEPS);
  65   if (IS_ARM(board) || IS_2560(board)) {
  66     ui->countdownBeep->addItem(tr("Voice"), TimerData::COUNTDOWN_VOICE);
  67     ui->countdownBeep->addItem(tr("Haptic"), TimerData::COUNTDOWN_HAPTIC);
  68   }
  69
  70   ui->value->setMaximumTime(firmware->getMaxTimerStart());
  71
  72   ui->persistent->setField(timer.persistent, this);
  73   ui->persistent->addItem(tr("Not persistent"), 0);
  74   ui->persistent->addItem(tr("Persistent (flight)"), 1);
  75   ui->persistent->addItem(tr("Persistent (manual reset)"), 2);
  76
  77   disableMouseScrolling();
  78   QWidget::setTabOrder(prevFocus, ui->name);
  79   QWidget::setTabOrder(ui->name, ui->value);
  80   QWidget::setTabOrder(ui->value, ui->mode);
  81   QWidget::setTabOrder(ui->mode, ui->countdownBeep);
  82   QWidget::setTabOrder(ui->countdownBeep, ui->minuteBeep);
  83   QWidget::setTabOrder(ui->minuteBeep, ui->persistent);
  84
  85   lock = false;
  86 }
  87
  88 TimerPanel::~TimerPanel()
  89 {
  90   delete ui;
  91 }
  92
  93 void TimerPanel::update()
  94 {
  95   rawSwitchItemModel->update();
  96
  97   int hour = timer.val / 3600;
  98   int min = (timer.val - (hour * 3600)) / 60;
  99   int sec = (timer.val - (hour * 3600)) % 60;
 100
 101   ui->value->setTime(QTime(hour, min, sec));
 102
 103   if (firmware->getCapability(PermTimers)) {
 104     int sign = 1;
 105     int pvalue = timer.pvalue;
 106     if (pvalue < 0) {
 107       pvalue = -pvalue;
 108       sign = -1;
 109     }
 110     int hours = pvalue / 3600;
 111     pvalue -= hours * 3600;
 112     int minutes = pvalue / 60;
 113     int seconds = pvalue % 60;
 114     ui->persistentValue->setText(QString(" %1(%2:%3:%4)").arg(sign<0 ? "-" :" ").arg(hours, 2, 10, QLatin1Char('0')).arg(minutes, 2, 10, QLatin1Char('0')).arg(seconds, 2, 10, QLatin1Char('0')));
 115   }
 116
 117   ui->minuteBeep->setChecked(timer.minuteBeep);
 118 }
 119
 120 QWidget * TimerPanel::getLastFocus()
 121 {
 122   return ui->persistent;
 123 }
 124
 125 void TimerPanel::on_value_editingFinished()
 126 {
 127   unsigned val = ui->value->time().hour()*3600 + ui->value->time().minute()*60 + ui->value->time().second();
 128   if (timer.val != val) {
 129     timer.val = val;
 130     emit modified();
 131   }
 132 }
 133
 134 void TimerPanel::on_mode_currentIndexChanged(int index)
 135 {
 136   if (!lock) {
 137     timer.mode = RawSwitch(ui->mode->itemData(index).toInt());
 138     emit modified();
 139   }
 140 }
 141
 142 void TimerPanel::on_minuteBeep_toggled(bool checked)
 143 {
 144   timer.minuteBeep = checked;
 145   emit modified();
 146 }
 147
 148 void TimerPanel::on_name_editingFinished()
 149 {
 150   if (QString(timer.name) != ui->name->text()) {
 151     int length = ui->name->maxLength();
 152     strncpy(timer.name, ui->name->text().toLatin1(), length);
 153     emit modified();
 154   }
 155 }
 156
 157 /******************************************************************************/
 158
 159 #define FAILSAFE_CHANNEL_HOLD    2000
 160 #define FAILSAFE_CHANNEL_NOPULSE 2001
 161
 162 #define MASK_PROTOCOL       1
 163 #define MASK_CHANNELS_COUNT 2
 164 #define MASK_RX_NUMBER      4
 165 #define MASK_CHANNELS_RANGE 8
 166 #define MASK_PPM_FIELDS     16
 167 #define MASK_FAILSAFES      32
 168 #define MASK_OPEN_DRAIN     64
 169 #define MASK_MULTIMODULE    128
 170 #define MASK_ANTENNA        256
 171 #define MASK_MULTIOPTION    512
 172 #define MASK_R9M            1024
 173 #define MASK_SBUSPPM_FIELDS 2048
 174 #define MASK_SUBTYPES       4096
 175
 176 quint8 ModulePanel::failsafesValueDisplayType = ModulePanel::FAILSAFE_DISPLAY_PERCENT;
 177
 178 ModulePanel::ModulePanel(QWidget * parent, ModelData & model, ModuleData & module, GeneralSettings & generalSettings, Firmware * firmware, int moduleIdx):
 179   ModelPanel(parent, model, generalSettings, firmware),
 180   module(module),
 181   moduleIdx(moduleIdx),
 182   ui(new Ui::Module)
 183 {
 184   lock = true;
 185
 186   ui->setupUi(this);
 187
 188   QString label;
 189   if (moduleIdx < 0) {
 190     label = tr("Trainer Port");
 191     if (IS_HORUS(firmware->getBoard())) {
 192       ui->trainerMode->setItemData(TRAINER_MODE_MASTER_CPPM_EXTERNAL_MODULE, 0, Qt::UserRole - 1);
 193       ui->trainerMode->setItemData(TRAINER_MODE_MASTER_SBUS_EXTERNAL_MODULE, 0, Qt::UserRole - 1);
 194     }
 195     if (generalSettings.hw_uartMode != UART_MODE_SBUS_TRAINER) {
 196       ui->trainerMode->setItemData(TRAINER_MODE_MASTER_BATTERY_COMPARTMENT, 0, Qt::UserRole - 1);
 197     }
 198     ui->trainerMode->setCurrentIndex(model.trainerMode);
 199     if (!IS_HORUS_OR_TARANIS(firmware->getBoard())) {
 200       ui->label_trainerMode->hide();
 201       ui->trainerMode->hide();
 202     }
 203     ui->formLayout_col1->setSpacing(0);
 204   }
 205   else {
 206     ui->label_trainerMode->hide();
 207     ui->trainerMode->hide();
 208     if (firmware->getCapability(NumModules) > 1) {
 209       if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
 210         if (moduleIdx == 0)
 211           label = tr("Internal Radio System");
 212         else
 213           label = tr("External Radio Module");
 214       }
 215       else {
 216         if (moduleIdx == 0)
 217           label = tr("Radio System");
 218         else
 219           label = tr("Extra Radio System");
 220       }
 221     }
 222     else {
 223       label = tr("Radio System");
 224     }
 225   }
 226   ui->label_module->setText(label);
 227
 228   // The protocols available on this board
 229   for (int i=0; i<PULSES_PROTOCOL_LAST; i++) {
 230     if (firmware->isAvailable((PulsesProtocol) i, moduleIdx)) {
 231       if (IS_TARANIS_XLITE(firmware->getBoard()) && i == PULSES_PXX_R9M)  //TODO remove when mini are handled as a different module type
 232         ui->protocol->addItem("FrSky R9M Mini", (QVariant) i);
 233       else
 234         ui->protocol->addItem(ModelPrinter::printModuleProtocol(i), (QVariant) i);
 235       if (i == module.protocol)
 236         ui->protocol->setCurrentIndex(ui->protocol->count()-1);
 237     }
 238   }
 239   for (int i=0; i<=MM_RF_PROTO_LAST; i++) {
 240     ui->multiProtocol->addItem(ModelPrinter::printMultiRfProtocol(i, false), (QVariant) i);
 241   }
 242
 243   ui->btnGrpValueType->setId(ui->optPercent, FAILSAFE_DISPLAY_PERCENT);
 244   ui->btnGrpValueType->setId(ui->optUs, FAILSAFE_DISPLAY_USEC);
 245   ui->btnGrpValueType->button(failsafesValueDisplayType)->setChecked(true);
 246
 247   setupFailsafes();
 248
 249   disableMouseScrolling();
 250
 251   update();
 252
 253   connect(ui->protocol, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &ModulePanel::onProtocolChanged);
 254   connect(ui->multiProtocol, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &ModulePanel::onMultiProtocolChanged);
 255   connect(this, &ModulePanel::channelsRangeChanged, this, &ModulePanel::setupFailsafes);
 256   connect(ui->btnGrpValueType, static_cast<void(QButtonGroup::*)(int)>(&QButtonGroup::buttonClicked), this, &ModulePanel::onFailsafesDisplayValueTypeChanged);
 257
 258   lock = false;
 259
 260 }
 261
 262 ModulePanel::~ModulePanel()
 263 {
 264   delete ui;
 265 }
 266
 267 bool ModulePanel::moduleHasFailsafes()
 268 {
 269   return (((PulsesProtocol)module.protocol == PulsesProtocol::PULSES_PXX_XJT_X16 || (PulsesProtocol)module.protocol == PulsesProtocol::PULSES_PXX_R9M)
 270          && firmware->getCapability(HasFailsafe));;
 271 }
 272
 273 void ModulePanel::setupFailsafes()
 274 {
 275   ChannelFailsafeWidgetsGroup grp;
 276   const int start = module.channelsStart;
 277   const int end = start + module.channelsCount;
 278   const bool hasFailsafe = moduleHasFailsafes();
 279
 280   lock = true;
 281
 282   QMutableMapIterator<int, ChannelFailsafeWidgetsGroup> i(failsafeGroupsMap);
 283   while (i.hasNext()) {
 284     i.next();
 285     grp = i.value();
 286     ui->failsafesLayout->removeWidget(grp.label);
 287     ui->failsafesLayout->removeWidget(grp.combo);
 288     ui->failsafesLayout->removeWidget(grp.sbPercent);
 289     ui->failsafesLayout->removeWidget(grp.sbUsec);
 290     if (i.key() < start || i.key() >= end || !hasFailsafe) {
 291       grp.label->deleteLater();
 292       grp.combo->deleteLater();
 293       grp.sbPercent->deleteLater();
 294       grp.sbUsec->deleteLater();
 295       i.remove();
 296     }
 297   }
 298
 299   if (!hasFailsafe)
 300     return;
 301
 302   int row = 0;
 303   int col = 0;
 304   int channelMax = model->getChannelsMax();
 305   int channelMaxUs = 512 * channelMax / 100 * 2;
 306
 307   for (int i = start; i < end; ++i) {
 308     if (failsafeGroupsMap.contains(i)) {
 309       grp = failsafeGroupsMap.value(i);
 310     }
 311     else {
 312       QLabel * label = new QLabel(this);
 313       label->setProperty("index", i);
 314       label->setText(QString::number(i+1));
 315
 316       QComboBox * combo = new QComboBox(this);
 317       combo->setProperty("index", i);
 318       combo->addItem(tr("Value"), 0);
 319       combo->addItem(tr("Hold"), FAILSAFE_CHANNEL_HOLD);
 320       combo->addItem(tr("No Pulse"), FAILSAFE_CHANNEL_NOPULSE);
 321
 322       QDoubleSpinBox * sbDbl = new QDoubleSpinBox(this);
 323       sbDbl->setProperty("index", i);
 324       sbDbl->setMinimumSize(QSize(20, 0));
 325       sbDbl->setRange(-channelMax, channelMax);
 326       sbDbl->setSingleStep(0.1);
 327       sbDbl->setDecimals(1);
 328
 329       QSpinBox * sbInt = new QSpinBox(this);
 330       sbInt->setProperty("index", i);
 331       sbInt->setMinimumSize(QSize(20, 0));
 332       sbInt->setRange(-channelMaxUs, channelMaxUs);
 333       sbInt->setSingleStep(1);
 334
 335       grp = ChannelFailsafeWidgetsGroup();
 336       grp.combo = combo;
 337       grp.sbPercent = sbDbl;
 338       grp.sbUsec = sbInt;
 339       grp.label = label;
 340       failsafeGroupsMap.insert(i, grp);
 341
 342       connect(combo, SIGNAL(currentIndexChanged(int)), this, SLOT(onFailsafeComboIndexChanged(int)));
 343       connect(sbInt, SIGNAL(valueChanged(int)), this, SLOT(onFailsafeUsecChanged(int)));
 344       connect(sbDbl, SIGNAL(valueChanged(double)), this, SLOT(onFailsafePercentChanged(double)));
 345     }
 346
 347     ui->failsafesLayout->addWidget(grp.label, row, col, Qt::AlignHCenter);
 348     ui->failsafesLayout->addWidget(grp.combo, row + 1, col, Qt::AlignHCenter);
 349     ui->failsafesLayout->addWidget(grp.sbPercent, row + 2, col, Qt::AlignHCenter);
 350     ui->failsafesLayout->addWidget(grp.sbUsec, row + 3, col, Qt::AlignHCenter);
 351     grp.sbPercent->setVisible(failsafesValueDisplayType == FAILSAFE_DISPLAY_PERCENT);
 352     grp.sbUsec->setVisible(failsafesValueDisplayType == FAILSAFE_DISPLAY_USEC);
 353
 354     updateFailsafe(i);
 355
 356     if (++col > 7) {
 357       row += 4;
 358       col = 0;
 359     }
 360   }
 361
 362   lock = false;
 363 }
 364
 365 void ModulePanel::update()
 366 {
 367   unsigned int mask = 0;
 368   PulsesProtocol protocol = (PulsesProtocol)module.protocol;
 369   unsigned int max_rx_num = 63;
 370
 371   if (moduleIdx >= 0) {
 372     mask |= MASK_PROTOCOL;
 373     switch (protocol) {
 374       case PULSES_PXX_R9M:
 375         mask |= MASK_R9M | MASK_SUBTYPES;
 376       case PULSES_PXX_XJT_X16:
 377       case PULSES_PXX_XJT_D8:
 378       case PULSES_PXX_XJT_LR12:
 379       case PULSES_PXX_DJT:
 380         mask |= MASK_CHANNELS_RANGE | MASK_CHANNELS_COUNT;
 381         if (protocol==PULSES_PXX_XJT_X16 || protocol==PULSES_PXX_XJT_LR12 || protocol==PULSES_PXX_R9M)
 382           mask |= MASK_RX_NUMBER;
 383         if ((IS_HORUS(firmware->getBoard()) || IS_TARANIS_XLITE(firmware->getBoard())) && moduleIdx==0)
 384           mask |= MASK_ANTENNA;
 385         break;
 386       case PULSES_LP45:
 387       case PULSES_DSM2:
 388       case PULSES_DSMX:
 389         mask |= MASK_CHANNELS_RANGE | MASK_RX_NUMBER;
 390         module.channelsCount = 6;
 391         max_rx_num = 20;
 392         break;
 393       case PULSES_CROSSFIRE:
 394         mask |= MASK_CHANNELS_RANGE;
 395         module.channelsCount = 16;
 396         break;
 397       case PULSES_PPM:
 398         mask |= MASK_PPM_FIELDS | MASK_SBUSPPM_FIELDS| MASK_CHANNELS_RANGE| MASK_CHANNELS_COUNT;
 399         if (IS_9XRPRO(firmware->getBoard())) {
 400           mask |= MASK_OPEN_DRAIN;
 401         }
 402         break;
 403       case PULSES_SBUS:
 404         module.channelsCount = 16;
 405         mask |=  MASK_SBUSPPM_FIELDS| MASK_CHANNELS_RANGE;
 406         break;
 407       case PULSES_MULTIMODULE:
 408         mask |= MASK_CHANNELS_RANGE | MASK_RX_NUMBER | MASK_MULTIMODULE | MASK_SUBTYPES;
 409         max_rx_num = 15;
 410         if (module.multi.rfProtocol == MM_RF_PROTO_DSM2)
 411           mask |= MASK_CHANNELS_COUNT;
 412         else
 413           module.channelsCount = 16;
 414         if (multiProtocols.getProtocol(module.multi.rfProtocol).optionsstr != nullptr)
 415           mask |= MASK_MULTIOPTION;
 416         if (multiProtocols.getProtocol(module.multi.rfProtocol).hasFailsafe)
 417           mask |= MASK_FAILSAFES;
 418         break;
 419       case PULSES_OFF:
 420         break;
 421       default:
 422         break;
 423     }
 424   }
 425   else if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
 426     if (model->trainerMode == TRAINER_SLAVE_JACK) {
 427       mask |= MASK_PPM_FIELDS | MASK_CHANNELS_RANGE | MASK_CHANNELS_COUNT;
 428     }
 429   }
 430   else if (model->trainerMode != TRAINER_MASTER_JACK) {
 431     mask |= MASK_PPM_FIELDS | MASK_CHANNELS_RANGE | MASK_CHANNELS_COUNT;
 432   }
 433
 434   if (moduleHasFailsafes()) {
 435     mask |= MASK_FAILSAFES;
 436   }
 437
 438   ui->label_protocol->setVisible(mask & MASK_PROTOCOL);
 439   ui->protocol->setVisible(mask & MASK_PROTOCOL);
 440   ui->label_rxNumber->setVisible(mask & MASK_RX_NUMBER);
 441   ui->rxNumber->setVisible(mask & MASK_RX_NUMBER);
 442   ui->rxNumber->setMaximum(max_rx_num);
 443   ui->rxNumber->setValue(module.modelId);
 444   ui->label_channelsStart->setVisible(mask & MASK_CHANNELS_RANGE);
 445   ui->channelsStart->setVisible(mask & MASK_CHANNELS_RANGE);
 446   ui->channelsStart->setValue(module.channelsStart+1);
 447   ui->label_channelsCount->setVisible(mask & MASK_CHANNELS_RANGE);
 448   ui->channelsCount->setVisible(mask & MASK_CHANNELS_RANGE);
 449   ui->channelsCount->setEnabled(mask & MASK_CHANNELS_COUNT);
 450   ui->channelsCount->setValue(module.channelsCount);
 451   ui->channelsCount->setSingleStep(firmware->getCapability(HasPPMStart) ? 1 : 2);
 452
 453   // PPM settings fields
 454   ui->label_ppmPolarity->setVisible(mask & MASK_SBUSPPM_FIELDS);
 455   ui->ppmPolarity->setVisible(mask & MASK_SBUSPPM_FIELDS);
 456   ui->ppmPolarity->setCurrentIndex(module.ppm.pulsePol);
 457   ui->label_ppmOutputType->setVisible(mask & MASK_OPEN_DRAIN);
 458   ui->ppmOutputType->setVisible(mask & MASK_OPEN_DRAIN);
 459   ui->ppmOutputType->setCurrentIndex(module.ppm.outputType);
 460   ui->label_ppmDelay->setVisible(mask & MASK_PPM_FIELDS);
 461   ui->ppmDelay->setVisible(mask & MASK_PPM_FIELDS);
 462   ui->ppmDelay->setValue(module.ppm.delay);
 463   ui->label_ppmFrameLength->setVisible(mask & MASK_SBUSPPM_FIELDS);
 464   ui->ppmFrameLength->setVisible(mask & MASK_SBUSPPM_FIELDS);
 465   ui->ppmFrameLength->setMinimum(module.channelsCount*(model->extendedLimits ? 2.250 : 2)+3.5);
 466   ui->ppmFrameLength->setMaximum(firmware->getCapability(PPMFrameLength));
 467   ui->ppmFrameLength->setValue(22.5+((double)module.ppm.frameLength)*0.5);
 468
 469   // Antenna selection on Horus and xlite
 470   ui->label_antenna->setVisible(mask & MASK_ANTENNA);
 471   ui->antennaMode->setVisible(mask & MASK_ANTENNA);
 472   if IS_HORUS_X12S(firmware->getBoard()) {
 473     ui->antennaMode->setItemText(1,tr("Ext. + Int"));
 474   }
 475   else {
 476     ui->antennaMode->setItemText(1,tr("External"));
 477   }
 478   ui->antennaMode->setCurrentIndex(module.pxx.external_antenna);
 479
 480   // R9M options
 481   ui->r9mPower->setVisible(mask & MASK_R9M);
 482   ui->label_r9mPower->setVisible(mask & MASK_R9M);
 483   ui->warning_r9mPower->setVisible((mask & MASK_R9M) && module.subType == R9M_LBT);
 484
 485   if (mask & MASK_R9M) {
 486     const QSignalBlocker blocker(ui->r9mPower);
 487     ui->r9mPower->clear();
 488     Board::Type board = firmware->getBoard();
 489     if (IS_TARANIS_XLITE(board)) {
 490       if (module.subType == R9M_FCC) {
 491         ui->r9mPower->addItem(tr("100 mW - 16CH"));
 492       }
 493       else {
 494         ui->r9mPower->addItem(tr("25 mW - 8CH"));
 495         ui->r9mPower->addItem(tr("25 mW - 16CH"));
 496         ui->r9mPower->addItem(tr("100 mW - 16CH, no telemetry"));
 497       }
 498     }
 499     else {
 500       if (module.subType == R9M_FCC) {
 501         ui->r9mPower->addItem(tr("10 mW - 16CH"));
 502         ui->r9mPower->addItem(tr("100 mW - 16CH"));
 503         ui->r9mPower->addItem(tr("500 mW - 16CH"));
 504         ui->r9mPower->addItem(tr("1000 mW - 16CH"));
 505       }
 506       else {
 507         ui->r9mPower->addItem(tr("25 mW - 8CH"));
 508         ui->r9mPower->addItem(tr("25 mW - 16CH"));
 509         ui->r9mPower->addItem(tr("200 mW - 16CH"));
 510         ui->r9mPower->addItem(tr("500 mW - 16CH"));
 511       }
 512     }
 513     ui->r9mPower->setCurrentIndex(module.pxx.power);
 514   }
 515
 516   // module subtype
 517   ui->label_multiSubType->setVisible(mask & MASK_SUBTYPES);
 518   ui->multiSubType->setVisible(mask & MASK_SUBTYPES);
 519   if (mask & MASK_SUBTYPES) {
 520     unsigned numEntries = 2;  // R9M FCC/EU
 521     if (mask & MASK_MULTIMODULE)
 522       numEntries = (module.multi.customProto ? 8 : multiProtocols.getProtocol(module.multi.rfProtocol).numSubytes());
 523
 524     const QSignalBlocker blocker(ui->multiSubType);
 525     ui->multiSubType->clear();
 526     for (unsigned i=0; i < numEntries; i++)
 527       ui->multiSubType->addItem(ModelPrinter::printModuleSubType(protocol, i, module.multi.rfProtocol, module.multi.customProto), i);
 528     ui->multiSubType->setCurrentIndex(module.subType);
 529   }
 530
 531   // Multi settings fields
 532   ui->label_multiProtocol->setVisible(mask & MASK_MULTIMODULE);
 533   ui->multiProtocol->setVisible(mask & MASK_MULTIMODULE);
 534   ui->label_option->setVisible(mask & MASK_MULTIOPTION);
 535   ui->optionValue->setVisible(mask & MASK_MULTIOPTION);
 536   ui->autoBind->setVisible(mask & MASK_MULTIMODULE);
 537   ui->lowPower->setVisible(mask & MASK_MULTIMODULE);
 538
 539   if (mask & MASK_MULTIMODULE) {
 540     ui->multiProtocol->setCurrentIndex(module.multi.rfProtocol);
 541     ui->autoBind->setChecked(module.multi.autoBindMode);
 542     ui->lowPower->setChecked(module.multi.lowPowerMode);
 543   }
 544
 545   if (mask & MASK_MULTIOPTION) {
 546     auto pdef = multiProtocols.getProtocol(module.multi.rfProtocol);
 547     ui->optionValue->setMinimum(pdef.getOptionMin());
 548     ui->optionValue->setMaximum(pdef.getOptionMax());
 549     ui->optionValue->setValue(module.multi.optionValue);
 550     ui->label_option->setText(qApp->translate("Multiprotocols", qPrintable(pdef.optionsstr)));
 551   }
 552
 553   // Failsafes
 554   ui->label_failsafeMode->setVisible(mask & MASK_FAILSAFES);
 555   ui->failsafeMode->setVisible(mask & MASK_FAILSAFES);
 556
 557   if ((mask & MASK_FAILSAFES) && module.failsafeMode == FAILSAFE_CUSTOM) {
 558     if (ui->failsafesGroupBox->isHidden()) {
 559       setupFailsafes();
 560       ui->failsafesGroupBox->setVisible(true);
 561     }
 562   }
 563   else {
 564     ui->failsafesGroupBox->setVisible(false);
 565   }
 566
 567   if (mask & MASK_FAILSAFES) {
 568     ui->failsafeMode->setCurrentIndex(module.failsafeMode);
 569
 570     if (firmware->getCapability(ChannelsName)) {
 571       int chan;
 572       QString name;
 573       QMapIterator<int, ChannelFailsafeWidgetsGroup> i(failsafeGroupsMap);
 574       while (i.hasNext()) {
 575         i.next();
 576         chan = i.key();
 577         name = QString(model->limitData[chan + module.channelsStart].name).trimmed();
 578         if (name.isEmpty())
 579           i.value().label->setText(QString::number(chan + 1));
 580         else
 581           i.value().label->setText(name);
 582       }
 583     }
 584   }
 585
 586   if (mask & MASK_CHANNELS_RANGE) {
 587     ui->channelsStart->setMaximum(33 - ui->channelsCount->value());
 588     ui->channelsCount->setMaximum(qMin(16, 33-ui->channelsStart->value()));
 589   }
 590 }
 591
 592 void ModulePanel::on_trainerMode_currentIndexChanged(int index)
 593 {
 594   if (!lock && model->trainerMode != (unsigned)index) {
 595     model->trainerMode = index;
 596     update();
 597     emit modified();
 598   }
 599 }
 600
 601 void ModulePanel::onProtocolChanged(int index)
 602 {
 603   if (!lock && module.protocol != ui->protocol->itemData(index).toInt()) {
 604     module.protocol = ui->protocol->itemData(index).toInt();
 605     update();
 606     emit modified();
 607   }
 608 }
 609
 610 void ModulePanel::on_ppmPolarity_currentIndexChanged(int index)
 611 {
 612   if (!lock && module.ppm.pulsePol != (bool)index) {
 613     module.ppm.pulsePol = index;
 614     emit modified();
 615   }
 616 }
 617
 618 void ModulePanel::on_antennaMode_currentIndexChanged(int index)
 619 {
 620   if (!lock && module.pxx.external_antenna != (bool)index) {
 621     module.pxx.external_antenna = index;
 622     emit modified();
 623   }
 624 }
 625
 626 void ModulePanel::on_r9mPower_currentIndexChanged(int index)
 627 {
 628   if (!lock && module.pxx.power != index) {
 629     module.pxx.power = index;
 630     emit modified();
 631   }
 632 }
 633
 634 void ModulePanel::on_ppmOutputType_currentIndexChanged(int index)
 635 {
 636   if (!lock && module.ppm.outputType != (bool)index) {
 637     module.ppm.outputType = index;
 638     emit modified();
 639   }
 640 }
 641
 642 void ModulePanel::on_channelsCount_editingFinished()
 643 {
 644   if (!lock && module.channelsCount != ui->channelsCount->value()) {
 645     module.channelsCount = ui->channelsCount->value();
 646     update();
 647     emit channelsRangeChanged();
 648     emit modified();
 649   }
 650 }
 651
 652 void ModulePanel::on_channelsStart_editingFinished()
 653 {
 654   if (!lock && module.channelsStart != (unsigned)ui->channelsStart->value() - 1) {
 655     module.channelsStart = (unsigned)ui->channelsStart->value() - 1;
 656     update();
 657     emit channelsRangeChanged();
 658     emit modified();
 659   }
 660 }
 661
 662 void ModulePanel::on_ppmDelay_editingFinished()
 663 {
 664   if (!lock && module.ppm.delay != ui->ppmDelay->value()) {
 665     // TODO only accept valid values
 666     module.ppm.delay = ui->ppmDelay->value();
 667     emit modified();
 668   }
 669 }
 670
 671 void ModulePanel::on_rxNumber_editingFinished()
 672 {
 673   if (module.modelId != (unsigned)ui->rxNumber->value()) {
 674     module.modelId = (unsigned)ui->rxNumber->value();
 675     emit modified();
 676   }
 677 }
 678
 679 void ModulePanel::on_ppmFrameLength_editingFinished()
 680 {
 681   int val = (ui->ppmFrameLength->value()-22.5) / 0.5;
 682   if (module.ppm.frameLength != val) {
 683     module.ppm.frameLength = val;
 684     emit modified();
 685   }
 686 }
 687
 688 void ModulePanel::on_failsafeMode_currentIndexChanged(int value)
 689 {
 690   if (!lock && module.failsafeMode != (unsigned)value) {
 691     module.failsafeMode = value;
 692     update();
 693     emit modified();
 694   }
 695 }
 696
 697 void ModulePanel::onMultiProtocolChanged(int index)
 698 {
 699   if (!lock && module.multi.rfProtocol != (unsigned)index) {
 700     lock=true;
 701     module.multi.rfProtocol = (unsigned int) index;
 702     unsigned int maxSubTypes = multiProtocols.getProtocol(index).numSubytes();
 703     if (module.multi.customProto)
 704       maxSubTypes=8;
 705     module.subType = std::min(module.subType, maxSubTypes -1);
 706     update();
 707     emit modified();
 708     lock = false;
 709   }
 710 }
 711
 712 void ModulePanel::on_optionValue_editingFinished()
 713 {
 714   if (module.multi.optionValue != ui->optionValue->value()) {
 715     module.multi.optionValue = ui->optionValue->value();
 716     emit modified();
 717   }
 718 }
 719
 720 void ModulePanel::on_multiSubType_currentIndexChanged(int index)
 721 {
 722   if (!lock && module.subType != (unsigned)index) {
 723     lock=true;
 724     module.subType = index;
 725     update();
 726     emit modified();
 727     lock =  false;
 728   }
 729 }
 730
 731 void ModulePanel::on_autoBind_stateChanged(int state)
 732 {
 733   module.multi.autoBindMode = (state == Qt::Checked);
 734 }
 735 void ModulePanel::on_lowPower_stateChanged(int state)
 736 {
 737   module.multi.lowPowerMode = (state == Qt::Checked);
 738 }
 739
 740 // updtSb (update spin box(es)): 0=none or bitmask of FailsafeValueDisplayTypes
 741 void ModulePanel::setChannelFailsafeValue(const int channel, const int value, quint8 updtSb)
 742 {
 743   if (channel < 0 || channel >= CPN_MAX_CHNOUT)
 744     return;
 745
 746   module.failsafeChannels[channel] = value;
 747   double pctVal = divRoundClosest(value * 1000, 1024) / 10.0;
 748   // qDebug() << value << pctVal;
 749
 750   if (failsafeGroupsMap.contains(channel)) {
 751     const ChannelFailsafeWidgetsGroup & grp = failsafeGroupsMap.value(channel);
 752     if ((updtSb & FAILSAFE_DISPLAY_PERCENT) && grp.sbPercent) {
 753       grp.sbPercent->blockSignals(true);
 754       grp.sbPercent->setValue(pctVal);
 755       grp.sbPercent->blockSignals(false);
 756     }
 757     if ((updtSb & FAILSAFE_DISPLAY_USEC) && grp.sbUsec) {
 758       grp.sbUsec->blockSignals(true);
 759       grp.sbUsec->setValue(value);
 760       grp.sbUsec->blockSignals(false);
 761     }
 762   }
 763   if (!lock)
 764     emit modified();
 765 }
 766
 767 void ModulePanel::onFailsafeUsecChanged(int value)
 768 {
 769   if (!sender())
 770     return;
 771
 772   bool ok = false;
 773   int channel = sender()->property("index").toInt(&ok);
 774   if (ok)
 775     setChannelFailsafeValue(channel, value, FAILSAFE_DISPLAY_PERCENT);
 776 }
 777
 778 void ModulePanel::onFailsafePercentChanged(double value)
 779 {
 780   if (!sender())
 781     return;
 782
 783   bool ok = false;
 784   int channel = sender()->property("index").toInt(&ok);
 785   if (ok)
 786     setChannelFailsafeValue(channel, divRoundClosest(int(value * 1024), 100), FAILSAFE_DISPLAY_USEC);
 787 }
 788
 789 void ModulePanel::onFailsafeComboIndexChanged(int index)
 790 {
 791   if (!sender())
 792     return;
 793
 794   QComboBox * cb = qobject_cast<QComboBox *>(sender());
 795
 796   if (cb && !lock) {
 797     lock = true;
 798     bool ok = false;
 799     int channel = sender()->property("index").toInt(&ok);
 800     if (ok) {
 801       module.failsafeChannels[channel] = cb->itemData(index).toInt();
 802       updateFailsafe(channel);
 803       emit modified();
 804     }
 805     lock = false;
 806   }
 807 }
 808
 809 void ModulePanel::onFailsafesDisplayValueTypeChanged(int type)
 810 {
 811   if (failsafesValueDisplayType != type) {
 812     failsafesValueDisplayType = type;
 813     foreach (ChannelFailsafeWidgetsGroup grp, failsafeGroupsMap) {
 814       if (grp.sbPercent)
 815         grp.sbPercent->setVisible(type == FAILSAFE_DISPLAY_PERCENT);
 816       if (grp.sbUsec)
 817         grp.sbUsec->setVisible(type == FAILSAFE_DISPLAY_USEC);
 818     }
 819   }
 820 }
 821
 822 void ModulePanel::onExtendedLimitsToggled()
 823 {
 824   double channelMaxPct = double(model->getChannelsMax());
 825   int channelMaxUs = 512 * channelMaxPct / 100 * 2;
 826   foreach (ChannelFailsafeWidgetsGroup grp, failsafeGroupsMap) {
 827     if (grp.sbPercent)
 828       grp.sbPercent->setRange(-channelMaxPct, channelMaxPct);
 829     if (grp.sbUsec)
 830       grp.sbUsec->setRange(-channelMaxUs, channelMaxUs);
 831   }
 832 }
 833
 834 void ModulePanel::updateFailsafe(int channel)
 835 {
 836   if (channel >= CPN_MAX_CHNOUT || !failsafeGroupsMap.contains(channel))
 837     return;
 838
 839   const int failsafeValue = module.failsafeChannels[channel];
 840   const ChannelFailsafeWidgetsGroup & grp = failsafeGroupsMap.value(channel);
 841   const bool valDisable = (failsafeValue == FAILSAFE_CHANNEL_HOLD || failsafeValue == FAILSAFE_CHANNEL_NOPULSE);
 842
 843   if (grp.combo)
 844     grp.combo->setCurrentIndex(grp.combo->findData(valDisable ? failsafeValue : 0));
 845   if (grp.sbPercent)
 846     grp.sbPercent->setDisabled(valDisable);
 847   if (grp.sbUsec)
 848     grp.sbUsec->setDisabled(valDisable);
 849
 850   if (!valDisable)
 851     setChannelFailsafeValue(channel, failsafeValue, (FAILSAFE_DISPLAY_PERCENT | FAILSAFE_DISPLAY_USEC));
 852 }
 853
 854 /******************************************************************************/
 855
 856 SetupPanel::SetupPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware):
 857   ModelPanel(parent, model, generalSettings, firmware),
 858   ui(new Ui::Setup)
 859 {
 860   Board::Type board = firmware->getBoard();
 861
 862   lock = true;
 863
 864   memset(modules, 0, sizeof(modules));
 865
 866   ui->setupUi(this);
 867
 868   QRegExp rx(CHAR_FOR_NAMES_REGEX);
 869   ui->name->setValidator(new QRegExpValidator(rx, this));
 870   ui->name->setMaxLength(firmware->getCapability(ModelName));
 871
 872   if (firmware->getCapability(ModelImage)) {
 873     QStringList items;
 874     items.append("");
 875     QString path = g.profile[g.id()].sdPath();
 876     path.append("/IMAGES/");
 877     QDir qd(path);
 878     if (qd.exists()) {
 879       QStringList filters;
 880       if(IS_HORUS(board)) {
 881         filters << "*.bmp" << "*.jpg" << "*.png";
 882         foreach ( QString file, qd.entryList(filters, QDir::Files) ) {
 883           QFileInfo fi(file);
 884           QString temp = fi.fileName();
 885           if (!items.contains(temp) && temp.length() <= 6+4) {
 886             items.append(temp);
 887           }
 888         }
 889       }
 890       else {
 891         filters << "*.bmp";
 892         foreach (QString file, qd.entryList(filters, QDir::Files)) {
 893           QFileInfo fi(file);
 894           QString temp = fi.completeBaseName();
 895           if (!items.contains(temp) && temp.length() <= 10+4) {
 896             items.append(temp);
 897           }
 898         }
 899       }
 900     }
 901     if (!items.contains(model.bitmap)) {
 902       items.append(model.bitmap);
 903     }
 904     items.sort();
 905     foreach (QString file, items) {
 906       ui->image->addItem(file);
 907       if (file == model.bitmap) {
 908         ui->image->setCurrentIndex(ui->image->count()-1);
 909         QString fileName = path;
 910         fileName.append(model.bitmap);
 911         if (!IS_HORUS(board))
 912           fileName.append(".bmp");
 913         QImage image(fileName);
 914         if (image.isNull() && !IS_HORUS(board)) {
 915           fileName = path;
 916           fileName.append(model.bitmap);
 917           fileName.append(".BMP");
 918           image.load(fileName);
 919         }
 920         if (!image.isNull()) {
 921           if (IS_HORUS(board)) {
 922             ui->imagePreview->setFixedSize(QSize(192, 114));
 923             ui->imagePreview->setPixmap(QPixmap::fromImage(image.scaled(192, 114)));
 924           }
 925           else {
 926             ui->imagePreview->setFixedSize(QSize(64, 32));
 927             ui->imagePreview->setPixmap(QPixmap::fromImage(image.scaled(64, 32)));
 928           }
 929         }
 930       }
 931     }
 932   }
 933   else {
 934     ui->image->hide();
 935     ui->modelImage_label->hide();
 936     ui->imagePreview->hide();
 937   }
 938
 939   QWidget * prevFocus = ui->image;
 940   for (int i=0; i<CPN_MAX_TIMERS; i++) {
 941     if (i<firmware->getCapability(Timers)) {
 942       timers[i] = new TimerPanel(this, model, model.timers[i], generalSettings, firmware, prevFocus);
 943       ui->gridLayout->addWidget(timers[i], 1+i, 1);
 944       connect(timers[i], &TimerPanel::modified, this, &SetupPanel::modified);
 945       prevFocus = timers[i]->getLastFocus();
 946     }
 947     else {
 948       foreach(QLabel *label, findChildren<QLabel *>(QRegExp(QString("label_timer%1").arg(i+1)))) {
 949         label->hide();
 950       }
 951     }
 952   }
 953
 954   if (firmware->getCapability(HasTopLcd)) {
 955     ui->toplcdTimer->setField(model.toplcdTimer, this);
 956     for (int i=0; i<CPN_MAX_TIMERS; i++) {
 957       if (i<firmware->getCapability(Timers)) {
 958         ui->toplcdTimer->addItem(tr("Timer %1").arg(i+1), i);
 959       }
 960     }
 961   }
 962   else {
 963     ui->toplcdTimerLabel->hide();
 964     ui->toplcdTimer->hide();
 965   }
 966
 967   if (!firmware->getCapability(HasDisplayText)) {
 968     ui->displayText->hide();
 969     ui->editText->hide();
 970   }
 971
 972   if (!firmware->getCapability(GlobalFunctions)) {
 973     ui->gfEnabled->hide();
 974   }
 975
 976   // Beep Center checkboxes
 977   prevFocus = ui->trimsDisplay;
 978   int analogs = CPN_MAX_STICKS + getBoardCapability(board, Board::Pots) + getBoardCapability(board, Board::Sliders);
 979   int genAryIdx = 0;
 980   for (int i=0; i < analogs + firmware->getCapability(RotaryEncoders); i++) {
 981     RawSource src((i < analogs) ? SOURCE_TYPE_STICK : SOURCE_TYPE_ROTARY_ENCODER, (i < analogs) ? i : analogs - i);
 982     QCheckBox * checkbox = new QCheckBox(this);
 983     checkbox->setProperty("index", i);
 984     checkbox->setText(src.toString(&model, &generalSettings));
 985     ui->centerBeepLayout->addWidget(checkbox, 0, i+1);
 986     connect(checkbox, SIGNAL(toggled(bool)), this, SLOT(onBeepCenterToggled(bool)));
 987     centerBeepCheckboxes << checkbox;
 988     if (IS_HORUS_OR_TARANIS(board)) {
 989       if (src.isPot(&genAryIdx) && !generalSettings.isPotAvailable(genAryIdx)) {
 990         checkbox->hide();
 991       }
 992       else if (src.isSlider(&genAryIdx) && !generalSettings.isSliderAvailable(genAryIdx)) {
 993         checkbox->hide();
 994       }
 995     }
 996     QWidget::setTabOrder(prevFocus, checkbox);
 997     prevFocus = checkbox;
 998   }
 999
1000   // Startup switches warnings
1001   for (int i=0; i<getBoardCapability(board, Board::Switches); i++) {
1002     Board::SwitchInfo switchInfo = Boards::getSwitchInfo(board, i);
1003     switchInfo.config = Board::SwitchType(generalSettings.switchConfig[i]);
1004     if (switchInfo.config == Board::SWITCH_NOT_AVAILABLE || switchInfo.config == Board::SWITCH_TOGGLE) {
1005       continue;
1006     }
1007     RawSource src(RawSourceType::SOURCE_TYPE_SWITCH, i);
1008     QLabel * label = new QLabel(this);
1009     QSlider * slider = new QSlider(this);
1010     QCheckBox * cb = new QCheckBox(this);
1011     slider->setProperty("index", i);
1012     slider->setOrientation(Qt::Vertical);
1013     slider->setMinimum(0);
1014     slider->setInvertedAppearance(true);
1015     slider->setInvertedControls(true);
1016     slider->setTickPosition(QSlider::TicksBothSides);
1017     slider->setMinimumSize(QSize(30, 50));
1018     slider->setMaximumSize(QSize(50, 50));
1019     slider->setSingleStep(1);
1020     slider->setPageStep(1);
1021     slider->setTickInterval(1);
1022     label->setText(src.toString(&model, &generalSettings));
1023     slider->setMaximum(switchInfo.config == Board::SWITCH_3POS ? 2 : 1);
1024     cb->setProperty("index", i);
1025     ui->switchesStartupLayout->addWidget(label, 0, i+1);
1026     ui->switchesStartupLayout->setAlignment(label, Qt::AlignCenter);
1027     ui->switchesStartupLayout->addWidget(slider, 1, i+1);
1028     ui->switchesStartupLayout->setAlignment(slider, Qt::AlignCenter);
1029     ui->switchesStartupLayout->addWidget(cb, 2, i+1);
1030     ui->switchesStartupLayout->setAlignment(cb, Qt::AlignCenter);
1031     connect(slider, SIGNAL(valueChanged(int)), this, SLOT(startupSwitchEdited(int)));
1032     connect(cb, SIGNAL(toggled(bool)), this, SLOT(startupSwitchToggled(bool)));
1033     startupSwitchesSliders << slider;
1034     startupSwitchesCheckboxes << cb;
1035     QWidget::setTabOrder(prevFocus, slider);
1036     QWidget::setTabOrder(slider, cb);
1037     prevFocus = cb;
1038   }
1039
1040   // Pot warnings
1041   prevFocus = ui->potWarningMode;
1042   if (IS_HORUS_OR_TARANIS(board)) {
1043     for (int i=0; i<getBoardCapability(board, Board::Pots)+getBoardCapability(board, Board::Sliders); i++) {
1044       RawSource src(SOURCE_TYPE_STICK, CPN_MAX_STICKS + i);
1045       QCheckBox * cb = new QCheckBox(this);
1046       cb->setProperty("index", i);
1047       cb->setText(src.toString(&model, &generalSettings));
1048       ui->potWarningLayout->addWidget(cb, 0, i+1);
1049       connect(cb, SIGNAL(toggled(bool)), this, SLOT(potWarningToggled(bool)));
1050       potWarningCheckboxes << cb;
1051       if (src.isPot(&genAryIdx) && !generalSettings.isPotAvailable(genAryIdx)) {
1052         cb->hide();
1053       }
1054       else if (src.isSlider(&genAryIdx) && !generalSettings.isSliderAvailable(genAryIdx)) {
1055         cb->hide();
1056       }
1057       QWidget::setTabOrder(prevFocus, cb);
1058       prevFocus = cb;
1059     }
1060   }
1061   else {
1062     ui->label_potWarning->hide();
1063     ui->potWarningMode->hide();
1064   }
1065
1066   if (IS_ARM(board)) {
1067     ui->trimsDisplay->setField(model.trimsDisplay, this);
1068   }
1069   else {
1070     ui->labelTrimsDisplay->hide();
1071     ui->trimsDisplay->hide();
1072   }
1073
1074   for (int i=0; i<firmware->getCapability(NumModules); i++) {
1075     modules[i] = new ModulePanel(this, model, model.moduleData[i], generalSettings, firmware, i);
1076     ui->modulesLayout->addWidget(modules[i]);
1077     connect(modules[i], &ModulePanel::modified, this, &SetupPanel::modified);
1078     connect(this, &SetupPanel::extendedLimitsToggled, modules[i], &ModulePanel::onExtendedLimitsToggled);
1079   }
1080
1081   if (firmware->getCapability(ModelTrainerEnable)) {
1082     modules[CPN_MAX_MODULES] = new ModulePanel(this, model, model.moduleData[CPN_MAX_MODULES], generalSettings, firmware, -1);
1083     ui->modulesLayout->addWidget(modules[CPN_MAX_MODULES]);
1084     connect(modules[CPN_MAX_MODULES], &ModulePanel::modified, this, &SetupPanel::modified);
1085   }
1086
1087   disableMouseScrolling();
1088
1089   lock = false;
1090 }
1091
1092 SetupPanel::~SetupPanel()
1093 {
1094   delete ui;
1095 }
1096
1097 void SetupPanel::on_extendedLimits_toggled(bool checked)
1098 {
1099   model->extendedLimits = checked;
1100   emit extendedLimitsToggled();
1101   emit modified();
1102 }
1103
1104 void SetupPanel::on_throttleWarning_toggled(bool checked)
1105 {
1106   model->disableThrottleWarning = !checked;
1107   emit modified();
1108 }
1109
1110 void SetupPanel::on_throttleReverse_toggled(bool checked)
1111 {
1112   model->throttleReversed = checked;
1113   emit modified();
1114 }
1115
1116 void SetupPanel::on_extendedTrims_toggled(bool checked)
1117 {
1118   model->extendedTrims = checked;
1119   emit modified();
1120 }
1121
1122 void SetupPanel::on_trimIncrement_currentIndexChanged(int index)
1123 {
1124   model->trimInc = index-2;
1125   emit modified();
1126 }
1127
1128 void SetupPanel::on_throttleSource_currentIndexChanged(int index)
1129 {
1130   if (!lock) {
1131     model->thrTraceSrc = index;
1132     emit modified();
1133   }
1134 }
1135
1136 void SetupPanel::on_name_editingFinished()
1137 {
1138   if (QString(model->name) != ui->name->text()) {
1139     int length = ui->name->maxLength();
1140     strncpy(model->name, ui->name->text().toLatin1(), length);
1141     emit modified();
1142   }
1143 }
1144
1145 void SetupPanel::on_image_currentIndexChanged(int index)
1146 {
1147   if (!lock) {
1148     Board::Type board = firmware->getBoard();
1149     strncpy(model->bitmap, ui->image->currentText().toLatin1(), 10);
1150     QString path = g.profile[g.id()].sdPath();
1151     path.append("/IMAGES/");
1152     QDir qd(path);
1153     if (qd.exists()) {
1154       QString fileName=path;
1155       fileName.append(model->bitmap);
1156       if (!IS_HORUS(board))
1157         fileName.append(".bmp");
1158       QImage image(fileName);
1159       if (image.isNull() && !IS_HORUS(board)) {
1160         fileName=path;
1161         fileName.append(model->bitmap);
1162         fileName.append(".BMP");
1163         image.load(fileName);
1164       }
1165       if (!image.isNull()) {
1166         if (IS_HORUS(board)) {
1167           ui->imagePreview->setFixedSize(QSize(192, 114));
1168           ui->imagePreview->setPixmap(QPixmap::fromImage(image.scaled(192, 114)));
1169         }
1170         else {
1171           ui->imagePreview->setFixedSize(QSize(64, 32));
1172           ui->imagePreview->setPixmap(QPixmap::fromImage(image.scaled(64, 32)));
1173         }
1174       }
1175       else {
1176         ui->imagePreview->clear();
1177       }
1178     }
1179     else {
1180       ui->imagePreview->clear();
1181     }
1182     emit modified();
1183   }
1184 }
1185
1186 void SetupPanel::populateThrottleSourceCB()
1187 {
1188   Board::Type board = firmware->getBoard();
1189   lock = true;
1190   ui->throttleSource->clear();
1191   ui->throttleSource->addItem(tr("THR"));
1192   for (int i=0; i<getBoardCapability(board, Board::Pots)+getBoardCapability(board, Board::Sliders); i++) {
1193     ui->throttleSource->addItem(firmware->getAnalogInputName(4+i), i);
1194   }
1195   for (int i=0; i<firmware->getCapability(Outputs); i++) {
1196     ui->throttleSource->addItem(RawSource(SOURCE_TYPE_CH, i).toString(model, &generalSettings));
1197   }
1198   ui->throttleSource->setCurrentIndex(model->thrTraceSrc);
1199   lock = false;
1200 }
1201
1202 void SetupPanel::update()
1203 {
1204   ui->name->setText(model->name);
1205   ui->throttleReverse->setChecked(model->throttleReversed);
1206   populateThrottleSourceCB();
1207   ui->throttleWarning->setChecked(!model->disableThrottleWarning);
1208   ui->trimIncrement->setCurrentIndex(model->trimInc+2);
1209   ui->throttleTrim->setChecked(model->thrTrim);
1210   ui->extendedLimits->setChecked(model->extendedLimits);
1211   ui->extendedTrims->setChecked(model->extendedTrims);
1212   ui->displayText->setChecked(model->displayChecklist);
1213   ui->gfEnabled->setChecked(!model->noGlobalFunctions);
1214
1215   updateBeepCenter();
1216   updateStartupSwitches();
1217
1218   if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
1219     updatePotWarnings();
1220   }
1221
1222   for (int i=0; i<firmware->getCapability(Timers); i++) {
1223     timers[i]->update();
1224   }
1225
1226   for (int i=0; i<CPN_MAX_MODULES+1; i++) {
1227     if (modules[i]) {
1228       modules[i]->update();
1229     }
1230   }
1231 }
1232
1233 void SetupPanel::updateBeepCenter()
1234 {
1235   for (int i=0; i<centerBeepCheckboxes.size(); i++) {
1236     centerBeepCheckboxes[i]->setChecked(model->beepANACenter & (0x01 << i));
1237   }
1238 }
1239
1240 void SetupPanel::updateStartupSwitches()
1241 {
1242   lock = true;
1243
1244   uint64_t switchStates = model->switchWarningStates;
1245   uint64_t value;
1246
1247   for (int i=0; i<startupSwitchesSliders.size(); i++) {
1248     QSlider * slider = startupSwitchesSliders[i];
1249     QCheckBox * cb = startupSwitchesCheckboxes[i];
1250     int index = slider->property("index").toInt();
1251     bool enabled = !(model->switchWarningEnable & (1 << index));
1252     if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
1253       value = (switchStates >> (2*index)) & 0x03;
1254       if (generalSettings.switchConfig[index] != Board::SWITCH_3POS && value == 2) {
1255         value = 1;
1256       }
1257     }
1258     else {
1259       value = (i==0 ? switchStates & 0x3 : switchStates & 0x1);
1260       switchStates >>= (i==0 ? 2 : 1);
1261     }
1262     slider->setValue(value);
1263     slider->setEnabled(enabled);
1264     cb->setChecked(enabled);
1265   }
1266
1267   lock = false;
1268 }
1269
1270 void SetupPanel::startupSwitchEdited(int value)
1271 {
1272   if (!lock) {
1273     int shift = 0;
1274     uint64_t mask;
1275     int index = sender()->property("index").toInt();
1276
1277     if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
1278       shift = index * 2;
1279       mask = 0x03ull << shift;
1280     }
1281     else {
1282       if (index == 0) {
1283         mask = 0x03;
1284       }
1285       else {
1286         shift = index+1;
1287         mask = 0x01ull << shift;
1288       }
1289     }
1290
1291     model->switchWarningStates &= ~mask;
1292
1293     if (IS_HORUS_OR_TARANIS(firmware->getBoard()) && generalSettings.switchConfig[index] != Board::SWITCH_3POS) {
1294       if (value == 1) {
1295         value = 2;
1296       }
1297     }
1298
1299     if (value) {
1300       model->switchWarningStates |= ((uint64_t)value << shift);
1301     }
1302
1303     updateStartupSwitches();
1304     emit modified();
1305   }
1306 }
1307
1308 void SetupPanel::startupSwitchToggled(bool checked)
1309 {
1310   if (!lock) {
1311     int index = sender()->property("index").toInt();
1312
1313     if (checked)
1314       model->switchWarningEnable &= ~(1 << index);
1315     else
1316       model->switchWarningEnable |= (1 << index);
1317
1318     updateStartupSwitches();
1319     emit modified();
1320   }
1321 }
1322
1323 void SetupPanel::updatePotWarnings()
1324 {
1325   lock = true;
1326   ui->potWarningMode->setCurrentIndex(model->potsWarningMode);
1327   for (int i=0; i<potWarningCheckboxes.size(); i++) {
1328     QCheckBox *checkbox = potWarningCheckboxes[i];
1329     int index = checkbox->property("index").toInt();
1330     checkbox->setChecked(!model->potsWarningEnabled[index]);
1331     checkbox->setDisabled(model->potsWarningMode == 0);
1332   }
1333   lock = false;
1334 }
1335
1336 void SetupPanel::potWarningToggled(bool checked)
1337 {
1338   if (!lock) {
1339     int index = sender()->property("index").toInt();
1340     model->potsWarningEnabled[index] = !checked;
1341     updatePotWarnings();
1342     emit modified();
1343   }
1344 }
1345
1346 void SetupPanel::on_potWarningMode_currentIndexChanged(int index)
1347 {
1348   if (!lock) {
1349     model->potsWarningMode = index;
1350     updatePotWarnings();
1351     emit modified();
1352   }
1353 }
1354
1355 void SetupPanel::on_displayText_toggled(bool checked)
1356 {
1357   model->displayChecklist = checked;
1358   emit modified();
1359 }
1360
1361 void SetupPanel::on_gfEnabled_toggled(bool checked)
1362 {
1363   model->noGlobalFunctions = !checked;
1364   emit modified();
1365 }
1366
1367 void SetupPanel::on_throttleTrim_toggled(bool checked)
1368 {
1369   model->thrTrim = checked;
1370   emit modified();
1371 }
1372
1373 void SetupPanel::onBeepCenterToggled(bool checked)
1374 {
1375   if (!lock) {
1376     int index = sender()->property("index").toInt();
1377     unsigned int mask = (0x01 << index);
1378     if (checked)
1379       model->beepANACenter |= mask;
1380     else
1381       model->beepANACenter &= ~mask;
1382     emit modified();
1383   }
1384 }
1385
1386 void SetupPanel::on_editText_clicked()
1387 {
1388   ChecklistDialog *g = new ChecklistDialog(this, ui->name->text());
1389   g->exec();
1390 }