piotr/edgetx-gx12
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity
Files
de49d155c6c0f6d270dd7b83f2c791f2a0a79189
edgetx-gx12/companion/src/modeledit/setup.cpp
T

1099 lines
32 KiB
C++
Raw Blame History

/*
* Copyright (C) OpenTX
*
* Based on code named
* th9x - http://code.google.com/p/th9x
* er9x - http://code.google.com/p/er9x
* gruvin9x - http://code.google.com/p/gruvin9x
*
* License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program 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.
*/
#include "setup.h"
#include "ui_setup.h"
#include "ui_setup_timer.h"
#include "ui_setup_module.h"
#include "helpers.h"
#include "appdata.h"
#include "modelprinter.h"
TimerPanel::TimerPanel(QWidget *parent, ModelData & model, TimerData & timer, GeneralSettings & generalSettings, Firmware * firmware, QWidget * prevFocus):
ModelPanel(parent, model, generalSettings, firmware),
timer(timer),
ui(new Ui::Timer)
{
Board::Type board = firmware->getBoard();
ui->setupUi(this);
lock = true;
// Name
int length = firmware->getCapability(TimersName);
if (length == 0) {
ui->name->hide();
}
else {
ui->name->setMaxLength(length);
ui->name->setText(timer.name);
}
// Mode
populateSwitchCB(ui->mode, timer.mode, generalSettings, TimersContext);
if (!firmware->getCapability(PermTimers)) {
ui->persistent->hide();
ui->persistentValue->hide();
}
ui->countdownBeep->setField(timer.countdownBeep, this);
ui->countdownBeep->addItem(tr("Silent"), TimerData::COUNTDOWN_SILENT);
ui->countdownBeep->addItem(tr("Beeps"), TimerData::COUNTDOWN_BEEPS);
if (IS_ARM(board) || IS_2560(board)) {
ui->countdownBeep->addItem(tr("Voice"), TimerData::COUNTDOWN_VOICE);
ui->countdownBeep->addItem(tr("Haptic"), TimerData::COUNTDOWN_HAPTIC);
}
ui->value->setMaximumTime(firmware->getMaxTimerStart());
ui->persistent->setField(timer.persistent, this);
ui->persistent->addItem(tr("Not persistent"), 0);
ui->persistent->addItem(tr("Persistent (flight)"), 1);
ui->persistent->addItem(tr("Persistent (manual reset)"), 2);
disableMouseScrolling();
QWidget::setTabOrder(prevFocus, ui->name);
QWidget::setTabOrder(ui->name, ui->value);
QWidget::setTabOrder(ui->value, ui->mode);
QWidget::setTabOrder(ui->mode, ui->countdownBeep);
QWidget::setTabOrder(ui->countdownBeep, ui->minuteBeep);
QWidget::setTabOrder(ui->minuteBeep, ui->persistent);
lock = false;
}
TimerPanel::~TimerPanel()
{
delete ui;
}
void TimerPanel::update()
{
int hour = timer.val / 3600;
int min = (timer.val - (hour * 3600)) / 60;
int sec = (timer.val - (hour * 3600)) % 60;
ui->value->setTime(QTime(hour, min, sec));
if (firmware->getCapability(PermTimers)) {
int sign = 1;
int pvalue = timer.pvalue;
if (pvalue < 0) {
pvalue = -pvalue;
sign = -1;
}
int hours = pvalue / 3600;
pvalue -= hours * 3600;
int minutes = pvalue / 60;
int seconds = pvalue % 60;
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')));
}
ui->minuteBeep->setChecked(timer.minuteBeep);
}
QWidget * TimerPanel::getLastFocus()
{
return ui->persistent;
}
void TimerPanel::on_value_editingFinished()
{
timer.val = ui->value->time().hour()*3600 + ui->value->time().minute()*60 + ui->value->time().second();
emit modified();
}
void TimerPanel::on_mode_currentIndexChanged(int index)
{
if (!lock) {
timer.mode = RawSwitch(ui->mode->itemData(index).toInt());
emit modified();
}
}
void TimerPanel::on_minuteBeep_toggled(bool checked)
{
timer.minuteBeep = checked;
emit modified();
}
void TimerPanel::on_name_editingFinished()
{
int length = ui->name->maxLength();
strncpy(timer.name, ui->name->text().toLatin1(), length);
emit modified();
}
/******************************************************************************/
#define FAILSAFE_CHANNEL_HOLD 2000
#define FAILSAFE_CHANNEL_NOPULSE 2001
ModulePanel::ModulePanel(QWidget * parent, ModelData & model, ModuleData & module, GeneralSettings & generalSettings, Firmware * firmware, int moduleIdx):
ModelPanel(parent, model, generalSettings, firmware),
module(module),
moduleIdx(moduleIdx),
ui(new Ui::Module)
{
lock = true;
ui->setupUi(this);
QString label;
if (moduleIdx < 0) {
label = tr("Trainer Port");
if (generalSettings.hw_uartMode != UART_MODE_SBUS_TRAINER) {
ui->trainerMode->setItemData(TRAINER_MODE_MASTER_BATTERY_COMPARTMENT, 0, Qt::UserRole - 1);
}
ui->trainerMode->setCurrentIndex(model.trainerMode);
if (!IS_HORUS_OR_TARANIS(firmware->getBoard())) {
ui->label_trainerMode->hide();
ui->trainerMode->hide();
}
}
else {
ui->label_trainerMode->hide();
ui->trainerMode->hide();
if (firmware->getCapability(NumModules) > 1) {
if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
if (moduleIdx == 0)
label = tr("Internal Radio System");
else
label = tr("External Radio Module");
}
else {
if (moduleIdx == 0)
label = tr("Radio System");
else
label = tr("Extra Radio System");
}
}
else {
label = tr("Radio System");
}
}
ui->label_module->setText(label);
// Antena selection for Horus
if (IS_HORUS(firmware->getBoard()) && moduleIdx == 0) {
ui->antennaMode->setCurrentIndex(module.ppm.pulsePol);
}
else {
ui->label_antenna->hide();
ui->antennaMode->hide();
}
// The protocols available on this board
for (int i=0; i<PULSES_PROTOCOL_LAST; i++) {
if (firmware->isAvailable((PulsesProtocol)i, moduleIdx)) {
ui->protocol->addItem(ModelPrinter::printModuleProtocol(i), (QVariant)i);
if (i == module.protocol) ui->protocol->setCurrentIndex(ui->protocol->count()-1);
}
}
for (int i=0; i<=MM_RF_PROTO_LAST; i++) {
ui->multiProtocol->addItem(ModelPrinter::printMultiRfProtocol(i, false), (QVariant) i);
}
if (firmware->getCapability(HasFailsafe)) {
for (int i=0; i<maxChannels; i++) {
QLabel * label = new QLabel(this);
label->setText(QString::number(i+1));
QComboBox * combo = new QComboBox(this);
combo->setProperty("index", i);
combo->addItem(tr("Value"), 0);
combo->addItem(tr("Hold"), FAILSAFE_CHANNEL_HOLD);
combo->addItem(tr("No Pulse"), FAILSAFE_CHANNEL_NOPULSE);
QDoubleSpinBox * spinbox = new QDoubleSpinBox(this);
spinbox->setMinimumSize(QSize(20, 0));
spinbox->setRange(-150, 150);
spinbox->setSingleStep(0.1);
spinbox->setDecimals(1);
label->setProperty("index", i);
spinbox->setProperty("index", i);
ui->failsafesLayout->addWidget(label, 3*(i/8), i%8, Qt::AlignHCenter);
ui->failsafesLayout->addWidget(combo, 1+3*(i/8), i%8, Qt::AlignHCenter);
ui->failsafesLayout->addWidget(spinbox, 2+3*(i/8), i%8, Qt::AlignHCenter);
failsafeGroups[i].combo = combo;
failsafeGroups[i].spinbox = spinbox;
failsafeGroups[i].label = label;
updateFailsafe(i);
connect(combo, SIGNAL(currentIndexChanged(int)), this, SLOT(onFailsafeComboIndexChanged(int)));
connect(spinbox, SIGNAL(valueChanged(double)), this, SLOT(onFailsafeSpinChanged(double)));
}
}
disableMouseScrolling();
lock = false;
}
ModulePanel::~ModulePanel()
{
delete ui;
}
#define MASK_PROTOCOL 1
#define MASK_CHANNELS_COUNT 2
#define MASK_RX_NUMBER 4
#define MASK_CHANNELS_RANGE 8
#define MASK_PPM_FIELDS 16
#define MASK_FAILSAFES 32
#define MASK_OPEN_DRAIN 64
#define MASK_MULTIMODULE 128
void ModulePanel::update()
{
unsigned int mask = 0;
PulsesProtocol protocol = (PulsesProtocol)module.protocol;
unsigned int max_rx_num = 63;
if (moduleIdx >= 0) {
mask |= MASK_PROTOCOL;
switch (protocol) {
case PULSES_PXX_XJT_X16:
case PULSES_PXX_XJT_D8:
case PULSES_PXX_XJT_LR12:
case PULSES_PXX_DJT:
mask |= MASK_CHANNELS_RANGE | MASK_CHANNELS_COUNT;
if (protocol==PULSES_PXX_XJT_X16) mask |= MASK_FAILSAFES | MASK_RX_NUMBER;
if (protocol==PULSES_PXX_XJT_LR12) mask |= MASK_RX_NUMBER;
break;
case PULSES_LP45:
case PULSES_DSM2:
case PULSES_DSMX:
mask |= MASK_CHANNELS_RANGE | MASK_RX_NUMBER;
module.channelsCount = 6;
max_rx_num = 20;
break;
case PULSES_CROSSFIRE:
mask |= MASK_CHANNELS_RANGE;
module.channelsCount = 16;
break;
case PULSES_PPM:
mask |= MASK_PPM_FIELDS | MASK_CHANNELS_RANGE| MASK_CHANNELS_COUNT;
if (IS_9XRPRO(firmware->getBoard())) {
mask |= MASK_OPEN_DRAIN;
}
break;
case PULSES_MULTIMODULE:
mask |= MASK_CHANNELS_RANGE | MASK_RX_NUMBER | MASK_MULTIMODULE;
break;
case PULSES_OFF:
default:
break;
}
}
else if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
if (model->trainerMode == TRAINER_SLAVE_JACK) {
mask |= MASK_PPM_FIELDS | MASK_CHANNELS_RANGE | MASK_CHANNELS_COUNT;
}
}
else if (model->trainerMode != TRAINER_MASTER_JACK) {
mask |= MASK_PPM_FIELDS | MASK_CHANNELS_RANGE | MASK_CHANNELS_COUNT;
}
ui->label_protocol->setVisible(mask & MASK_PROTOCOL);
ui->protocol->setVisible(mask & MASK_PROTOCOL);
ui->label_rxNumber->setVisible(mask & MASK_RX_NUMBER);
ui->rxNumber->setVisible(mask & MASK_RX_NUMBER);
ui->rxNumber->setMaximum(max_rx_num);
ui->rxNumber->setValue(module.modelId);
ui->label_channelsStart->setVisible(mask & MASK_CHANNELS_RANGE);
ui->channelsStart->setVisible(mask & MASK_CHANNELS_RANGE);
ui->channelsStart->setValue(module.channelsStart+1);
ui->label_channelsCount->setVisible(mask & MASK_CHANNELS_RANGE);
ui->channelsCount->setVisible(mask & MASK_CHANNELS_RANGE);
ui->channelsCount->setEnabled(mask & MASK_CHANNELS_COUNT);
ui->channelsCount->setValue(module.channelsCount);
ui->channelsCount->setSingleStep(firmware->getCapability(HasPPMStart) ? 1 : 2);
// PPM settings fields
ui->label_ppmPolarity->setVisible(mask & MASK_PPM_FIELDS);
ui->ppmPolarity->setVisible(mask & MASK_PPM_FIELDS);
ui->ppmPolarity->setCurrentIndex(module.ppm.pulsePol);
ui->label_ppmOutputType->setVisible(mask & MASK_OPEN_DRAIN);
ui->ppmOutputType->setVisible(mask & MASK_OPEN_DRAIN);
ui->ppmOutputType->setCurrentIndex(module.ppm.outputType);
ui->label_ppmDelay->setVisible(mask & MASK_PPM_FIELDS);
ui->ppmDelay->setVisible(mask & MASK_PPM_FIELDS);
ui->ppmDelay->setValue(module.ppm.delay);
ui->label_ppmFrameLength->setVisible(mask & MASK_PPM_FIELDS);
ui->ppmFrameLength->setVisible(mask & MASK_PPM_FIELDS);
ui->ppmFrameLength->setMinimum(module.channelsCount*(model->extendedLimits ? 2.250 : 2)+3.5);
ui->ppmFrameLength->setMaximum(firmware->getCapability(PPMFrameLength));
ui->ppmFrameLength->setValue(22.5+((double)module.ppm.frameLength)*0.5);
// Multi settings fields
ui->label_multiProtocol->setVisible(mask & MASK_MULTIMODULE);
ui->multiProtocol->setVisible(mask & MASK_MULTIMODULE);
ui->multiProtocol->setCurrentIndex(module.multi.rfProtocol);
ui->label_multiSubType->setVisible(mask & MASK_MULTIMODULE);
ui->multiSubType->setVisible(mask & MASK_MULTIMODULE);
if (mask & MASK_MULTIMODULE) {
int numEntries = getNumSubtypes(static_cast<MultiModuleRFProtocols>(module.multi.rfProtocol));
if (module.multi.customProto)
numEntries=8;
// Removes extra items
ui->multiSubType->setMaxCount(numEntries);
for (int i=0; i < numEntries; i++) {
if (i < ui->multiSubType->count())
ui->multiSubType->setItemText(i, ModelPrinter::printMultiSubType(module.multi.rfProtocol, module.multi.customProto, i));
else
ui->multiSubType->addItem(ModelPrinter::printMultiSubType(module.multi.rfProtocol, module.multi.customProto, i), (QVariant) i);
}
}
ui->multiSubType->setCurrentIndex(module.subType);
ui->autoBind->setVisible(mask & MASK_MULTIMODULE);
ui->autoBind->setChecked(module.multi.autoBindMode ? Qt::Checked : Qt::Unchecked);
ui->lowPower->setVisible(mask & MASK_MULTIMODULE);
ui->lowPower->setChecked(module.multi.lowPowerMode ? Qt::Checked : Qt::Unchecked);
if (firmware->getCapability(HasFailsafe)) {
ui->label_failsafeMode->setVisible(mask & MASK_FAILSAFES);
ui->failsafeMode->setVisible(mask & MASK_FAILSAFES);
ui->failsafeMode->setCurrentIndex(module.failsafeMode);
ui->failsafesFrame->setEnabled(module.failsafeMode == FAILSAFE_CUSTOM);
if (firmware->getCapability(ChannelsName) > 0) {
for(int i=0; i<maxChannels;i++) {
QString name = QString(model->limitData[i+module.channelsStart].name).trimmed();
if (!name.isEmpty()) {
failsafeGroups[i].label->setText(name);
}
else {
failsafeGroups[i].label->setText(QString::number(i+1));
}
}
}
}
else {
mask = 0;
}
ui->failsafesLayoutLabel->setVisible(mask & MASK_FAILSAFES);
ui->failsafesFrame->setVisible(mask & MASK_FAILSAFES);
if (mask & MASK_CHANNELS_RANGE) {
ui->channelsStart->setMaximum(33 - ui->channelsCount->value());
ui->channelsCount->setMaximum(qMin(16, 33-ui->channelsStart->value()));
}
}
void ModulePanel::on_trainerMode_currentIndexChanged(int index)
{
if (!lock) {
model->trainerMode = index;
update();
emit modified();
}
}
void ModulePanel::on_protocol_currentIndexChanged(int index)
{
if (!lock) {
module.protocol = ui->protocol->itemData(index).toInt();
update();
emit modified();
}
}
void ModulePanel::on_ppmPolarity_currentIndexChanged(int index)
{
module.ppm.pulsePol = index;
emit modified();
}
void ModulePanel::on_antennaMode_currentIndexChanged(int index)
{
module.ppm.pulsePol = index;
emit modified();
}
void ModulePanel::on_ppmOutputType_currentIndexChanged(int index)
{
module.ppm.outputType = index;
emit modified();
}
void ModulePanel::on_channelsCount_editingFinished()
{
if (!lock) {
module.channelsCount = ui->channelsCount->value();
update();
emit modified();
}
}
void ModulePanel::on_channelsStart_editingFinished()
{
if (!lock) {
module.channelsStart = ui->channelsStart->value() - 1;
update();
emit modified();
}
}
void ModulePanel::on_ppmDelay_editingFinished()
{
if (!lock) {
// TODO only accept valid values
module.ppm.delay = ui->ppmDelay->value();
emit modified();
}
}
void ModulePanel::on_rxNumber_editingFinished()
{
module.modelId = ui->rxNumber->value();
emit modified();
}
void ModulePanel::on_ppmFrameLength_editingFinished()
{
module.ppm.frameLength = (ui->ppmFrameLength->value()-22.5) / 0.5;
emit modified();
}
void ModulePanel::on_failsafeMode_currentIndexChanged(int value)
{
if (!lock) {
module.failsafeMode = value;
update();
emit modified();
}
}
void ModulePanel::onFailsafeSpinChanged(double value)
{
if (!lock) {
int channel = sender()->property("index").toInt();
module.failsafeChannels[channel] = (value*1024)/100;
emit modified();
}
}
void ModulePanel::onFailsafeComboIndexChanged(int index)
{
if (!lock) {
lock = true;
int channel = sender()->property("index").toInt();
module.failsafeChannels[channel] = ((QComboBox *)sender())->itemData(index).toInt();
updateFailsafe(channel);
emit modified();
lock = false;
}
}
void ModulePanel::on_multiProtocol_currentIndexChanged(int index)
{
if (!lock) {
lock=true;
module.multi.rfProtocol = index;
unsigned int maxSubTypes = getNumSubtypes(static_cast<MultiModuleRFProtocols>(index));
if (module.multi.customProto)
maxSubTypes=8;
module.subType = std::min(module.subType, maxSubTypes -1);
update();
emit modified();
lock = false;
}
}
void ModulePanel::on_multiSubType_currentIndexChanged(int index)
{
if (!lock) {
lock=true;
module.subType = index;
update();
emit modified();
lock = false;
}
}
void ModulePanel::on_autoBind_stateChanged(int state)
{
module.multi.autoBindMode = (state == Qt::Checked);
}
void ModulePanel::on_lowPower_stateChanged(int state)
{
module.multi.lowPowerMode = (state == Qt::Checked);
}
void ModulePanel::updateFailsafe(int channel)
{
int failsafeValue = module.failsafeChannels[channel];
QComboBox * combo = failsafeGroups[channel].combo;
QDoubleSpinBox * spinbox = failsafeGroups[channel].spinbox;
if (failsafeValue == FAILSAFE_CHANNEL_HOLD) {
combo->setCurrentIndex(1);
spinbox->setEnabled(false);
spinbox->setValue(0);
}
else if (failsafeValue == FAILSAFE_CHANNEL_NOPULSE) {
combo->setCurrentIndex(2);
spinbox->setEnabled(false);
spinbox->setValue(0);
}
else {
combo->setCurrentIndex(0);
spinbox->setEnabled(true);
spinbox->setValue(((double)failsafeValue*100)/1024);
}
}
/******************************************************************************/
SetupPanel::SetupPanel(QWidget * parent, ModelData & model, GeneralSettings & generalSettings, Firmware * firmware):
ModelPanel(parent, model, generalSettings, firmware),
ui(new Ui::Setup)
{
Board::Type board = firmware->getBoard();
lock = true;
memset(modules, 0, sizeof(modules));
ui->setupUi(this);
QRegExp rx(CHAR_FOR_NAMES_REGEX);
ui->name->setValidator(new QRegExpValidator(rx, this));
ui->name->setMaxLength(firmware->getCapability(ModelName));
if (firmware->getCapability(ModelImage)) {
QStringList items;
items.append("");
QString path = g.profile[g.id()].sdPath();
path.append("/IMAGES/");
QDir qd(path);
if (qd.exists()) {
QStringList filters;
if(IS_HORUS(board)) {
filters << "*.bmp" << "*.jpg" << "*.png";
foreach ( QString file, qd.entryList(filters, QDir::Files) ) {
QFileInfo fi(file);
QString temp = fi.fileName();
if (!items.contains(temp) && temp.length() <= 6+4) {
items.append(temp);
}
}
}
else {
filters << "*.bmp";
foreach (QString file, qd.entryList(filters, QDir::Files)) {
QFileInfo fi(file);
QString temp = fi.completeBaseName();
if (!items.contains(temp) && temp.length() <= 10+4) {
items.append(temp);
}
}
}
}
if (!items.contains(model.bitmap)) {
items.append(model.bitmap);
}
items.sort();
foreach (QString file, items) {
ui->image->addItem(file);
if (file == model.bitmap) {
ui->image->setCurrentIndex(ui->image->count()-1);
QString fileName = path;
fileName.append(model.bitmap);
if (!IS_HORUS(board))
fileName.append(".bmp");
QImage image(fileName);
if (image.isNull() && !IS_HORUS(board)) {
fileName = path;
fileName.append(model.bitmap);
fileName.append(".BMP");
image.load(fileName);
}
if (!image.isNull()) {
if (IS_HORUS(board)) {
ui->imagePreview->setFixedSize(QSize(192, 114));
ui->imagePreview->setPixmap(QPixmap::fromImage(image.scaled(192, 114)));
}
else {
ui->imagePreview->setFixedSize(QSize(64, 32));
ui->imagePreview->setPixmap(QPixmap::fromImage(image.scaled(64, 32)));
}
}
}
}
}
else {
ui->image->hide();
ui->modelImage_label->hide();
ui->imagePreview->hide();
}
QWidget * prevFocus = ui->image;
for (int i=0; i<CPN_MAX_TIMERS; i++) {
if (i<firmware->getCapability(Timers)) {
timers[i] = new TimerPanel(this, model, model.timers[i], generalSettings, firmware, prevFocus);
ui->gridLayout->addWidget(timers[i], 1+i, 1);
connect(timers[i], SIGNAL(modified()), this, SLOT(onChildModified()));
prevFocus = timers[i]->getLastFocus();
}
else {
foreach(QLabel *label, findChildren<QLabel *>(QRegExp(QString("label_timer%1").arg(i+1)))) {
label->hide();
}
}
}
if (firmware->getCapability(HasTopLcd)) {
ui->toplcdTimer->setField(model.toplcdTimer, this);
for (int i=0; i<CPN_MAX_TIMERS; i++) {
if (i<firmware->getCapability(Timers)) {
ui->toplcdTimer->addItem(tr("Timer %1").arg(i+1), i);
}
}
}
else {
ui->toplcdTimerLabel->hide();
ui->toplcdTimer->hide();
}
if (!firmware->getCapability(HasDisplayText)) {
ui->displayText->hide();
}
if (!firmware->getCapability(GlobalFunctions)) {
ui->gfEnabled->hide();
}
// Beep Center checkboxes
prevFocus = ui->trimsDisplay;
int analogs = CPN_MAX_STICKS + firmware->getCapability(Pots) + firmware->getCapability(Sliders);
for (int i=0; i<analogs+firmware->getCapability(RotaryEncoders); i++) {
QCheckBox * checkbox = new QCheckBox(this);
checkbox->setProperty("index", i);
checkbox->setText(i<analogs ? firmware->getAnalogInputName(i) : RotaryEncoderString(i-analogs));
ui->centerBeepLayout->addWidget(checkbox, 0, i+1);
connect(checkbox, SIGNAL(toggled(bool)), this, SLOT(onBeepCenterToggled(bool)));
centerBeepCheckboxes << checkbox;
if (IS_HORUS_OR_TARANIS(board)) {
RawSource src(SOURCE_TYPE_STICK, i);
if (src.isPot() && !generalSettings.isPotAvailable(i-CPN_MAX_STICKS)) {
checkbox->hide();
}
else if (src.isSlider() && !generalSettings.isSliderAvailable(i-CPN_MAX_STICKS-firmware->getCapability(Pots))) {
checkbox->hide();
}
}
QWidget::setTabOrder(prevFocus, checkbox);
prevFocus = checkbox;
}
// Startup switches warnings
for (int i=0; i<firmware->getCapability(Switches); i++) {
Board::SwitchInfo switchInfo = getSwitchInfo(board, i);
if (IS_HORUS_OR_TARANIS(board)) {
switchInfo.config = Board::SwitchType(generalSettings.switchConfig[i]);
}
if (switchInfo.config == Board::SWITCH_NOT_AVAILABLE || switchInfo.config == Board::SWITCH_TOGGLE) {
continue;
}
QLabel * label = new QLabel(this);
QSlider * slider = new QSlider(this);
QCheckBox * cb = new QCheckBox(this);
slider->setProperty("index", i);
slider->setOrientation(Qt::Vertical);
slider->setMinimum(0);
slider->setInvertedAppearance(true);
slider->setTickPosition(QSlider::TicksBothSides);
slider->setMinimumSize(QSize(30, 50));
slider->setMaximumSize(QSize(50, 50));
slider->setSingleStep(1);
slider->setPageStep(1);
slider->setTickInterval(1);
label->setText(switchInfo.name);
slider->setMaximum(switchInfo.config == Board::SWITCH_3POS ? 2 : 1);
cb->setProperty("index", i);
ui->switchesStartupLayout->addWidget(label, 0, i+1);
ui->switchesStartupLayout->setAlignment(label, Qt::AlignCenter);
ui->switchesStartupLayout->addWidget(slider, 1, i+1);
ui->switchesStartupLayout->setAlignment(slider, Qt::AlignCenter);
ui->switchesStartupLayout->addWidget(cb, 2, i+1);
ui->switchesStartupLayout->setAlignment(cb, Qt::AlignCenter);
connect(slider, SIGNAL(valueChanged(int)), this, SLOT(startupSwitchEdited(int)));
connect(cb, SIGNAL(toggled(bool)), this, SLOT(startupSwitchToggled(bool)));
startupSwitchesSliders << slider;
startupSwitchesCheckboxes << cb;
QWidget::setTabOrder(prevFocus, slider);
QWidget::setTabOrder(slider, cb);
prevFocus = cb;
}
// Pot warnings
prevFocus = ui->potWarningMode;
if (IS_HORUS_OR_TARANIS(board)) {
for (int i=0; i<firmware->getCapability(Pots)+firmware->getCapability(Sliders); i++) {
QCheckBox * cb = new QCheckBox(this);
cb->setProperty("index", i);
cb->setText(firmware->getAnalogInputName(i+4));
ui->potWarningLayout->addWidget(cb, 0, i+1);
connect(cb, SIGNAL(toggled(bool)), this, SLOT(potWarningToggled(bool)));
potWarningCheckboxes << cb;
if (RawSource(SOURCE_TYPE_STICK, CPN_MAX_STICKS+i).isPot()) {
if (!generalSettings.isPotAvailable(i)) {
cb->hide();
}
}
else {
if (!generalSettings.isSliderAvailable(i-firmware->getCapability(Pots))) {
cb->hide();
}
}
QWidget::setTabOrder(prevFocus, cb);
prevFocus = cb;
}
}
else {
ui->label_potWarning->hide();
ui->potWarningMode->hide();
}
if (IS_ARM(board)) {
ui->trimsDisplay->setField(model.trimsDisplay, this);
}
else {
ui->labelTrimsDisplay->hide();
ui->trimsDisplay->hide();
}
for (int i=0; i<firmware->getCapability(NumModules); i++) {
modules[i] = new ModulePanel(this, model, model.moduleData[i], generalSettings, firmware, i);
ui->modulesLayout->addWidget(modules[i]);
connect(modules[i], SIGNAL(modified()), this, SLOT(onChildModified()));
}
if (firmware->getCapability(ModelTrainerEnable)) {
modules[CPN_MAX_MODULES] = new ModulePanel(this, model, model.moduleData[CPN_MAX_MODULES], generalSettings, firmware, -1);
ui->modulesLayout->addWidget(modules[CPN_MAX_MODULES]);
connect(modules[CPN_MAX_MODULES], SIGNAL(modified()), this, SLOT(onChildModified()));
}
disableMouseScrolling();
lock = false;
}
SetupPanel::~SetupPanel()
{
delete ui;
}
void SetupPanel::on_extendedLimits_toggled(bool checked)
{
model->extendedLimits = checked;
emit extendedLimitsToggled();
emit modified();
}
void SetupPanel::on_throttleWarning_toggled(bool checked)
{
model->disableThrottleWarning = !checked;
emit modified();
}
void SetupPanel::on_throttleReverse_toggled(bool checked)
{
model->throttleReversed = checked;
emit modified();
}
void SetupPanel::on_extendedTrims_toggled(bool checked)
{
model->extendedTrims = checked;
emit modified();
}
void SetupPanel::on_trimIncrement_currentIndexChanged(int index)
{
model->trimInc = index-2;
emit modified();
}
void SetupPanel::on_throttleSource_currentIndexChanged(int index)
{
if (!lock) {
model->thrTraceSrc = index;
emit modified();
}
}
void SetupPanel::on_name_editingFinished()
{
int length = ui->name->maxLength();
strncpy(model->name, ui->name->text().toLatin1(), length);
emit modified();
}
void SetupPanel::on_image_currentIndexChanged(int index)
{
if (!lock) {
Board::Type board = firmware->getBoard();
strncpy(model->bitmap, ui->image->currentText().toLatin1(), 10);
QString path = g.profile[g.id()].sdPath();
path.append("/IMAGES/");
QDir qd(path);
if (qd.exists()) {
QString fileName=path;
fileName.append(model->bitmap);
if (!IS_HORUS(board))
fileName.append(".bmp");
QImage image(fileName);
if (image.isNull() && !IS_HORUS(board)) {
fileName=path;
fileName.append(model->bitmap);
fileName.append(".BMP");
image.load(fileName);
}
if (!image.isNull()) {
if (IS_HORUS(board)) {
ui->imagePreview->setFixedSize(QSize(192, 114));
ui->imagePreview->setPixmap(QPixmap::fromImage(image.scaled(192, 114)));
}
else {
ui->imagePreview->setFixedSize(QSize(64, 32));
ui->imagePreview->setPixmap(QPixmap::fromImage(image.scaled(64, 32)));
}
}
else {
ui->imagePreview->clear();
}
}
else {
ui->imagePreview->clear();
}
emit modified();
}
}
void SetupPanel::populateThrottleSourceCB()
{
lock = true;
ui->throttleSource->clear();
ui->throttleSource->addItem(QObject::tr("THR"));
for (int i=0; i<firmware->getCapability(Pots)+firmware->getCapability(Sliders); i++) {
ui->throttleSource->addItem(firmware->getAnalogInputName(4+i), i);
}
for (int i=0; i<firmware->getCapability(Outputs); i++) {
ui->throttleSource->addItem(ModelPrinter::printChannelName(i));
}
ui->throttleSource->setCurrentIndex(model->thrTraceSrc);
lock = false;
}
void SetupPanel::update()
{
ui->name->setText(model->name);
ui->throttleReverse->setChecked(model->throttleReversed);
populateThrottleSourceCB();
ui->throttleWarning->setChecked(!model->disableThrottleWarning);
ui->trimIncrement->setCurrentIndex(model->trimInc+2);
ui->throttleTrim->setChecked(model->thrTrim);
ui->extendedLimits->setChecked(model->extendedLimits);
ui->extendedTrims->setChecked(model->extendedTrims);
ui->displayText->setChecked(model->displayChecklist);
ui->gfEnabled->setChecked(!model->noGlobalFunctions);
updateBeepCenter();
updateStartupSwitches();
if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
updatePotWarnings();
}
for (int i=0; i<firmware->getCapability(Timers); i++) {
timers[i]->update();
}
for (int i=0; i<CPN_MAX_MODULES+1; i++) {
if (modules[i]) {
modules[i]->update();
}
}
}
void SetupPanel::updateBeepCenter()
{
for (int i=0; i<centerBeepCheckboxes.size(); i++) {
centerBeepCheckboxes[i]->setChecked(model->beepANACenter & (0x01 << i));
}
}
void SetupPanel::updateStartupSwitches()
{
lock = true;
uint64_t switchStates = model->switchWarningStates;
uint64_t value;
for (int i=0; i<startupSwitchesSliders.size(); i++) {
QSlider * slider = startupSwitchesSliders[i];
QCheckBox * cb = startupSwitchesCheckboxes[i];
int index = slider->property("index").toInt();
bool enabled = !(model->switchWarningEnable & (1 << index));
if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
value = (switchStates >> 2*index) & 0x03;
if (generalSettings.switchConfig[index] != Board::SWITCH_3POS && value == 2) {
value = 1;
}
}
else {
value = (i==0 ? switchStates & 0x3 : switchStates & 0x1);
switchStates >>= (i==0 ? 2 : 1);
}
slider->setValue(value);
slider->setEnabled(enabled);
cb->setChecked(enabled);
}
lock = false;
}
void SetupPanel::startupSwitchEdited(int value)
{
if (!lock) {
int shift = 0;
uint64_t mask;
int index = sender()->property("index").toInt();
if (IS_HORUS_OR_TARANIS(firmware->getBoard())) {
shift = index * 2;
mask = 0x03ul << shift;
}
else {
if (index == 0) {
mask = 0x03;
}
else {
shift = index+1;
mask = 0x01ull << shift;
}
}
model->switchWarningStates &= ~mask;
if (IS_HORUS_OR_TARANIS(firmware->getBoard()) && generalSettings.switchConfig[index] != Board::SWITCH_3POS) {
if (value == 1) {
value = 2;
}
}
if (value) {
model->switchWarningStates |= ((uint64_t)value << shift);
}
updateStartupSwitches();
emit modified();
}
}
void SetupPanel::startupSwitchToggled(bool checked)
{
if (!lock) {
int index = sender()->property("index").toInt();
if (checked)
model->switchWarningEnable &= ~(1 << index);
else
model->switchWarningEnable |= (1 << index);
updateStartupSwitches();
emit modified();
}
}
void SetupPanel::updatePotWarnings()
{
lock = true;
ui->potWarningMode->setCurrentIndex(model->potsWarningMode);
for (int i=0; i<potWarningCheckboxes.size(); i++) {
QCheckBox *checkbox = potWarningCheckboxes[i];
int index = checkbox->property("index").toInt();
checkbox->setChecked(!model->potsWarningEnabled[index]);
checkbox->setDisabled(model->potsWarningMode == 0);
}
lock = false;
}
void SetupPanel::potWarningToggled(bool checked)
{
if (!lock) {
int index = sender()->property("index").toInt();
model->potsWarningEnabled[index] = !checked;
updatePotWarnings();
emit modified();
}
}
void SetupPanel::on_potWarningMode_currentIndexChanged(int index)
{
if (!lock) {
model->potsWarningMode = index;
updatePotWarnings();
emit modified();
}
}
void SetupPanel::on_displayText_toggled(bool checked)
{
model->displayChecklist = checked;
emit modified();
}
void SetupPanel::on_gfEnabled_toggled(bool checked)
{
model->noGlobalFunctions = !checked;
emit modified();
}
void SetupPanel::on_throttleTrim_toggled(bool checked)
{
model->thrTrim = checked;
emit modified();
}
void SetupPanel::onBeepCenterToggled(bool checked)
{
if (!lock) {
int index = sender()->property("index").toInt();
unsigned int mask = (0x01 << index);
if (checked)
model->beepANACenter |= mask;
else
model->beepANACenter &= ~mask;
emit modified();
}
}
void SetupPanel::onChildModified()
{
emit modified();
}
Reference in New Issue View Git Blame Copy Permalink