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

7434 lines
298 KiB
C++
Raw Blame History

#include "modeledit.h"
#include "ui_modeledit.h"
#include "helpers.h"
#include "edge.h"
#include "node.h"
#include "expodialog.h"
#include "mixerdialog.h"
#include "simulatordialog.h"
#include "xsimulatordialog.h"
#include "modelconfigdialog.h"
#include <assert.h>
#include <QtGui>
#include <QApplication>
#define BC_BIT_RUD (0x01)
#define BC_BIT_ELE (0x02)
#define BC_BIT_THR (0x04)
#define BC_BIT_AIL (0x08)
#define BC_BIT_P1 (0x10)
#define BC_BIT_P2 (0x20)
#define BC_BIT_P3 (0x40)
#define BC_BIT_P4 (0x80)
#define BC_BIT_REA (0x80)
#define BC_BIT_REB (0x100)
#define RUD (1)
#define ELE (2)
#define THR (3)
#define AIL (4)
#define GFX_MARGIN 16
ModelEdit::ModelEdit(RadioData &radioData, uint8_t id, bool openWizard, bool isNew, QWidget *parent) :
QDialog(parent),
redrawCurve(true),
openWizard(openWizard),
isNew(isNew),
ui(new Ui::ModelEdit),
radioData(radioData),
id_model(id),
g_model(radioData.models[id]),
g_eeGeneral(radioData.generalSettings)
{
ui->setupUi(this);
setupMixerListWidget();
setupExposListWidget();
QSettings settings("companion9x", "companion9x");
ui->tabWidget->setCurrentIndex(settings.value("modelEditTab", 0).toInt());
QRegExp rx(CHAR_FOR_NAMES_REGEX);
ui->modelNameLE->setValidator(new QRegExpValidator(rx, this));
ui->phase0Name->setValidator(new QRegExpValidator(rx, this));
ui->phase1Name->setValidator(new QRegExpValidator(rx, this));
ui->phase2Name->setValidator(new QRegExpValidator(rx, this));
ui->phase3Name->setValidator(new QRegExpValidator(rx, this));
ui->phase4Name->setValidator(new QRegExpValidator(rx, this));
ui->phase5Name->setValidator(new QRegExpValidator(rx, this));
ui->phase6Name->setValidator(new QRegExpValidator(rx, this));
ui->phase7Name->setValidator(new QRegExpValidator(rx, this));
ui->phase8Name->setValidator(new QRegExpValidator(rx, this));
ui->cname_LE->setValidator(new QRegExpValidator(rx, this));
#ifdef PHONON
phononLock=false;
clickObject = new Phonon::MediaObject(this);
clickOutput = new Phonon::AudioOutput(Phonon::NoCategory, this);
Phonon::createPath(clickObject, clickOutput);
connect(clickObject, SIGNAL(stateChanged(Phonon::State,Phonon::State)), this, SLOT(mediaPlayer_state(Phonon::State,Phonon::State)));
#endif
tabModelEditSetup();
tabPhases();
tabExpos();
tabMixes();
tabLimits();
tabCurves();
tabCustomSwitches();
selectedSwitch=0;
int telTab=10;
int fswTab=9;
if (GetEepromInterface()->getCapability(FSSwitch)) {
ui->tabSafetySwitches->setDisabled(true);
ui->tabWidget->removeTab(8);
telTab--;
fswTab--;
} else {
tabSafetySwitches();
}
if (GetEepromInterface()->getCapability(CustomFunctions)==0 ) {
ui->tabCustomFunctions->setDisabled(true);
ui->tabWidget->removeTab(fswTab);
telTab--;
} else {
tabCustomFunctions();
selectedFunction=0;
}
tabTemplates();
tabHeli();
if (GetEepromInterface()->getCapability(Telemetry) & TM_HASTELEMETRY) {
tabTelemetry();
} else {
ui->tabTelemetry->setDisabled(true);
ui->tabWidget->removeTab(telTab);
}
ui->tabWidget->setCurrentIndex(0);
ui->curvePreview->setMinimumWidth(240);
ui->curvePreview->setMinimumHeight(240);
resizeEvent();
QTimer::singleShot(0, this, SLOT(shrink()));
if (openWizard) {
QTimer::singleShot(1, this, SLOT(wizard()));
}
}
ModelEdit::~ModelEdit()
{
delete ui;
}
float ModelEdit::getBarStep(int barId)
{
switch (barId-1) {
case TELEMETRY_SOURCE_TX_BATT:
return 0.1;
break;
case TELEMETRY_SOURCE_TIMER1:
case TELEMETRY_SOURCE_TIMER2:
return 3;
break;
case TELEMETRY_SOURCE_A1:
case TELEMETRY_SOURCE_A1_MIN:
return (ui->a1RatioSB->value()/255);
break;
case TELEMETRY_SOURCE_A2:
case TELEMETRY_SOURCE_A2_MIN:
return (ui->a2RatioSB->value()/255);
break;
case TELEMETRY_SOURCE_ALT:
case TELEMETRY_SOURCE_GPS_ALT:
case TELEMETRY_SOURCE_ALT_MAX:
case TELEMETRY_SOURCE_ALT_MIN:
return 8;
break;
case TELEMETRY_SOURCE_RPM:
case TELEMETRY_SOURCE_RPM_MAX:
return 50;
break;
case TELEMETRY_SOURCE_CELLS_SUM:
case TELEMETRY_SOURCE_VFAS:
return 0.1;
break;
case TELEMETRY_SOURCE_CELL:
return 0.02;
break;
case TELEMETRY_SOURCE_HDG:
return 2;
break;
case TELEMETRY_SOURCE_DIST:
case TELEMETRY_SOURCE_DIST_MAX:
return 8;
break;
case TELEMETRY_SOURCE_CURRENT_MAX:
case TELEMETRY_SOURCE_CURRENT:
return 0.5;
break;
case TELEMETRY_SOURCE_POWER:
return 5;
break;
case TELEMETRY_SOURCE_CONSUMPTION:
return 20;
break;
case TELEMETRY_SOURCE_SPEED:
case TELEMETRY_SOURCE_SPEED_MAX:
if (g_model.frsky.imperial==1) {
return 1;
} else {
return 1.852;
}
break;
default:
return 1;
break;
}
}
void ModelEdit::setupExposListWidget()
{
ExposlistWidget = new MixersList(this, true);
QPushButton * qbUp = new QPushButton(this);
QPushButton * qbDown = new QPushButton(this);
QPushButton * qbClear = new QPushButton(this);
qbUp->setText(tr("Move Up"));
qbUp->setIcon(QIcon(":/images/moveup.png"));
qbUp->setShortcut(QKeySequence(tr("Ctrl+Up")));
qbDown->setText(tr("Move Down"));
qbDown->setIcon(QIcon(":/images/movedown.png"));
qbDown->setShortcut(QKeySequence(tr("Ctrl+Down")));
qbClear->setText(tr("Clear Expo Settings"));
qbClear->setIcon(QIcon(":/images/clear.png"));
ui->exposLayout->addWidget(ExposlistWidget,1,1,1,3);
ui->exposLayout->addWidget(qbUp,2,1);
ui->exposLayout->addWidget(qbClear,2,2);
ui->exposLayout->addWidget(qbDown,2,3);
connect(ExposlistWidget,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(expolistWidget_customContextMenuRequested(QPoint)));
connect(ExposlistWidget,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(expolistWidget_doubleClicked(QModelIndex)));
connect(ExposlistWidget,SIGNAL(mimeDropped(int,const QMimeData*,Qt::DropAction)),this,SLOT(mimeExpoDropped(int,const QMimeData*,Qt::DropAction)));
connect(qbUp,SIGNAL(pressed()),SLOT(moveExpoUp()));
connect(qbDown,SIGNAL(pressed()),SLOT(moveExpoDown()));
connect(qbClear,SIGNAL(pressed()),SLOT(clearExpos()));
connect(ExposlistWidget,SIGNAL(keyWasPressed(QKeyEvent*)), this, SLOT(expolistWidget_KeyPress(QKeyEvent*)));
}
void ModelEdit::setupMixerListWidget()
{
MixerlistWidget = new MixersList(this, false); // TODO enum
QPushButton * qbUp = new QPushButton(this);
QPushButton * qbDown = new QPushButton(this);
QPushButton * qbClear = new QPushButton(this);
qbUp->setText(tr("Move Up"));
qbUp->setIcon(QIcon(":/images/moveup.png"));
qbUp->setShortcut(QKeySequence(tr("Ctrl+Up")));
qbDown->setText(tr("Move Down"));
qbDown->setIcon(QIcon(":/images/movedown.png"));
qbDown->setShortcut(QKeySequence(tr("Ctrl+Down")));
qbClear->setText(tr("Clear Mixes"));
qbClear->setIcon(QIcon(":/images/clear.png"));
ui->mixersLayout->addWidget(MixerlistWidget,1,1,1,3);
ui->mixersLayout->addWidget(qbUp,2,1);
ui->mixersLayout->addWidget(qbClear,2,2);
ui->mixersLayout->addWidget(qbDown,2,3);
connect(MixerlistWidget,SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(mixerlistWidget_customContextMenuRequested(QPoint)));
connect(MixerlistWidget,SIGNAL(doubleClicked(QModelIndex)),this,SLOT(mixerlistWidget_doubleClicked(QModelIndex)));
connect(MixerlistWidget,SIGNAL(mimeDropped(int,const QMimeData*,Qt::DropAction)),this,SLOT(mimeMixerDropped(int,const QMimeData*,Qt::DropAction)));
connect(qbUp,SIGNAL(pressed()),SLOT(moveMixUp()));
connect(qbDown,SIGNAL(pressed()),SLOT(moveMixDown()));
connect(qbClear,SIGNAL(pressed()),SLOT(clearMixes()));
connect(MixerlistWidget,SIGNAL(keyWasPressed(QKeyEvent*)), this, SLOT(mixerlistWidget_KeyPress(QKeyEvent*)));
}
void ModelEdit::resizeEvent(QResizeEvent *event)
{
if(ui->curvePreview->scene())
{
QRect qr = ui->curvePreview->contentsRect();
ui->curvePreview->scene()->setSceneRect(GFX_MARGIN, GFX_MARGIN, qr.width()-GFX_MARGIN*2, qr.height()-GFX_MARGIN*2);
drawCurve();
}
QDialog::resizeEvent(event);
}
void ModelEdit::applyBaseTemplate()
{
clearMixes(false);
applyTemplate(0);
updateSettings();
tabMixes();
}
void ModelEdit::updateSettings()
{
radioData.models[id_model] = g_model;
emit modelValuesChanged();
}
void ModelEdit::on_tabWidget_currentChanged(int index)
{
QSettings settings("companion9x", "companion9x");
settings.setValue("modelEditTab",index);//ui->tabWidget->currentIndex());
resizeEvent();
}
void ModelEdit::fssldValueChanged()
{
if (fsLock)
return;
fsLock=true;
QSpinBox * fssb1[] = { ui->fsm1SB_1, ui->fsm1SB_2,ui->fsm1SB_3,ui->fsm1SB_4,ui->fsm1SB_5,ui->fsm1SB_6,ui->fsm1SB_7,ui->fsm1SB_8,
ui->fsm1SB_9, ui->fsm1SB_10,ui->fsm1SB_11,ui->fsm1SB_12,ui->fsm1SB_13,ui->fsm1SB_14,ui->fsm1SB_15,ui->fsm1SB_16, NULL };
QSpinBox * fssb2[] = { ui->fsm2SB_1, ui->fsm2SB_2,ui->fsm2SB_3,ui->fsm2SB_4,ui->fsm2SB_5,ui->fsm2SB_6,ui->fsm2SB_7,ui->fsm2SB_8,
ui->fsm2SB_9, ui->fsm2SB_10,ui->fsm2SB_11,ui->fsm2SB_12,ui->fsm2SB_13,ui->fsm2SB_14,ui->fsm2SB_15,ui->fsm2SB_16, NULL };
QSlider *sl = qobject_cast<QSlider*>(sender());
int fsId=sl->objectName().mid(sl->objectName().lastIndexOf("_")+1).toInt()-1;
int moduleid=sl->objectName().mid(3,1).toInt();
if (moduleid==1) {
fssb1[fsId]->setValue(sl->value());
} else {
fssb2[fsId]->setValue(sl->value());
}
fsLock=false;
}
void ModelEdit::fssbValueChanged()
{
if (fsLock)
return;
fsLock=true;
QSlider * fssld1[] = { ui->fsm1SL_1, ui->fsm1SL_2,ui->fsm1SL_3,ui->fsm1SL_4,ui->fsm1SL_5,ui->fsm1SL_6,ui->fsm1SL_7,ui->fsm1SL_8,
ui->fsm1SL_9, ui->fsm1SL_10,ui->fsm1SL_11,ui->fsm1SL_12,ui->fsm1SL_13,ui->fsm1SL_14,ui->fsm1SL_15,ui->fsm1SL_16, NULL };
QSlider * fssld2[] = { ui->fsm2SL_1, ui->fsm2SL_2,ui->fsm2SL_3,ui->fsm2SL_4,ui->fsm2SL_5,ui->fsm2SL_6,ui->fsm2SL_7,ui->fsm2SL_8,
ui->fsm2SL_9, ui->fsm2SL_10,ui->fsm2SL_11,ui->fsm2SL_12,ui->fsm2SL_13,ui->fsm2SL_14,ui->fsm2SL_15,ui->fsm2SL_16, NULL };
QSpinBox *sb = qobject_cast<QSpinBox*>(sender());
int fsId=sb->objectName().mid(sb->objectName().lastIndexOf("_")+1).toInt()-1;
int moduleid=sb->objectName().mid(3,1).toInt();
if (moduleid==1) {
fssld1[fsId]->setValue(sb->value());
} else {
fssld2[fsId]->setValue(sb->value());
}
fsLock=false;
}
void ModelEdit::fssldEdited()
{
QSlider *sl = qobject_cast<QSlider*>(sender());
int fsId=sl->objectName().mid(sl->objectName().lastIndexOf("_")+1).toInt()-1;
int moduleid=sl->objectName().mid(3,1).toInt();
if (moduleid==1) {
g_model.moduleData[0].failsafeChannels[fsId]=sl->value();
} else {
g_model.moduleData[1].failsafeChannels[fsId]=sl->value();
}
updateSettings();
}
void ModelEdit::fssbEdited()
{
QSpinBox *sb = qobject_cast<QSpinBox*>(sender());
int fsId=sb->objectName().mid(sb->objectName().lastIndexOf("_")+1).toInt()-1;
int moduleid=sb->objectName().mid(3,1).toInt();
if (moduleid==1) {
g_model.moduleData[0].failsafeChannels[fsId]=sb->value();
} else {
g_model.moduleData[1].failsafeChannels[fsId]=sb->value();
}
updateSettings();
}
void ModelEdit::tabModelEditSetup()
{
//name
QLabel * pmsl[] = {ui->swwarn_label, ui->swwarn0_label, ui->swwarn4_label, NULL};
QCheckBox * pmchkb[] = {ui->swwarn1_ChkB,ui->swwarn2_ChkB,ui->swwarn3_ChkB,ui->swwarn5_ChkB,ui->swwarn6_ChkB, NULL};
QSlider * tpmsld[] = {ui->chkSA, ui->chkSB, ui->chkSC, ui->chkSD, ui->chkSE, ui->chkSF, ui->chkSG, NULL};
QSlider * fssld1[] = { ui->fsm1SL_1, ui->fsm1SL_2,ui->fsm1SL_3,ui->fsm1SL_4,ui->fsm1SL_5,ui->fsm1SL_6,ui->fsm1SL_7,ui->fsm1SL_8,
ui->fsm1SL_9, ui->fsm1SL_10,ui->fsm1SL_11,ui->fsm1SL_12,ui->fsm1SL_13,ui->fsm1SL_14,ui->fsm1SL_15,ui->fsm1SL_16, NULL };
QSlider * fssld2[] = { ui->fsm2SL_1, ui->fsm2SL_2,ui->fsm2SL_3,ui->fsm2SL_4,ui->fsm2SL_5,ui->fsm2SL_6,ui->fsm2SL_7,ui->fsm2SL_8,
ui->fsm2SL_9, ui->fsm2SL_10,ui->fsm2SL_11,ui->fsm2SL_12,ui->fsm2SL_13,ui->fsm2SL_14,ui->fsm2SL_15,ui->fsm2SL_16, NULL };
QSpinBox * fssb1[] = { ui->fsm1SB_1, ui->fsm1SB_2,ui->fsm1SB_3,ui->fsm1SB_4,ui->fsm1SB_5,ui->fsm1SB_6,ui->fsm1SB_7,ui->fsm1SB_8,
ui->fsm1SB_9, ui->fsm1SB_10,ui->fsm1SB_11,ui->fsm1SB_12,ui->fsm1SB_13,ui->fsm1SB_14,ui->fsm1SB_15,ui->fsm1SB_16, NULL };
QSpinBox * fssb2[] = { ui->fsm2SB_1, ui->fsm2SB_2,ui->fsm2SB_3,ui->fsm2SB_4,ui->fsm2SB_5,ui->fsm2SB_6,ui->fsm2SB_7,ui->fsm2SB_8,
ui->fsm2SB_9, ui->fsm2SB_10,ui->fsm2SB_11,ui->fsm2SB_12,ui->fsm2SB_13,ui->fsm2SB_14,ui->fsm2SB_15,ui->fsm2SB_16, NULL };
if (IS_TARANIS(GetEepromInterface()->getBoard())) {
ui->modelNameLE->setMaxLength(12);
} else {
ui->modelNameLE->setMaxLength(10);
}
ui->modelNameLE->setText(g_model.name);
fsLock=true;
if (GetEepromInterface()->getCapability(NumModules)<2) {
ui->rf2_GB->hide();
}
if (!GetEepromInterface()->getCapability(HasFailsafe)) {
ui->FSGB_1 ->hide();
ui->FSGB_2->hide();
ui->ModelSetupTab->setTabEnabled(1,0);
} else {
if (GetEepromInterface()->getCapability(HasFailsafe)<32) {
ui->FSGB_2->hide();
}
for (int i=0; fssld1[i]; i++) {
fssld1[i]->setValue(g_model.moduleData[0].failsafeChannels[i]);
fssld2[i]->setValue(g_model.moduleData[1].failsafeChannels[i]);
fssb1[i]->setValue(g_model.moduleData[0].failsafeChannels[i]);
fssb2[i]->setValue(g_model.moduleData[1].failsafeChannels[i]);
connect(fssld1[i],SIGNAL(valueChanged(int)),this,SLOT(fssldValueChanged()));
connect(fssld2[i],SIGNAL(valueChanged(int)),this,SLOT(fssldValueChanged()));
connect(fssb1[i],SIGNAL(valueChanged(int)),this,SLOT(fssbValueChanged()));
connect(fssb2[i],SIGNAL(valueChanged(int)),this,SLOT(fssbValueChanged()));
connect(fssld1[i],SIGNAL(sliderReleased()),this,SLOT(fssldEdited()));
connect(fssld2[i],SIGNAL(sliderReleased()),this,SLOT(fssldEdited()));
connect(fssb1[i],SIGNAL(editingFinished()),this,SLOT(fssbEdited()));
connect(fssb2[i],SIGNAL(editingFinished()),this,SLOT(fssbEdited()));
}
}
fsLock=false;
//timer1 mode direction value
populateTimerSwitchCB(ui->timer1ModeCB,g_model.timers[0].mode,GetEepromInterface()->getCapability(TimerTriggerB));
int min = g_model.timers[0].val/60;
int sec = g_model.timers[0].val%60;
ui->timer1ValTE->setTime(QTime(0,min,sec));
ui->timer1DirCB->setCurrentIndex(g_model.timers[0].dir);
if (!GetEepromInterface()->getCapability(ModelVoice)) {
ui->modelVoice_SB->hide();
ui->modelVoice_label->hide();
} else {
ui->modelVoice_SB->setValue(g_model.modelVoice+260);
}
if (!GetEepromInterface()->getCapability(PerModelThrottleInvert)) {
ui->label_thrrev->hide();
ui->thrrevChkB->hide();
} else {
ui->thrrevChkB->setChecked(g_model.throttleReversed);
}
if (!GetEepromInterface()->getCapability(ModelImage)) {
ui->modelImage_CB->hide();
ui->modelImage_label->hide();
ui->modelImage_image->hide();
} else {
modelImageLock=true;
QStringList items;
items.append("");
QSettings settings("companion9x", "companion9x");
QString path=settings.value("sdPath", ".").toString();
path.append("/BMP/");
QDir qd(path);
int vml= GetEepromInterface()->getCapability(VoicesMaxLength)+4;
if (qd.exists()) {
QStringList filters;
filters << "*.bmp" << "*.bmp";
foreach ( QString file, qd.entryList(filters, QDir::Files) ) {
QFileInfo fi(file);
QString temp=fi.completeBaseName();
if (!items.contains(temp) && temp.length()<=vml) {
items.append(temp);
}
}
}
if (!items.contains(g_model.bitmap)) {
items.append(g_model.bitmap);
}
items.sort();
ui->modelImage_CB->clear();
foreach ( QString file, items ) {
ui->modelImage_CB->addItem(file);
if (file==g_model.bitmap) {
ui->modelImage_CB->setCurrentIndex(ui->modelImage_CB->count()-1);
QString fileName=path;
fileName.append(g_model.bitmap);
fileName.append(".bmp");
QImage image(fileName);
if (image.isNull()) {
fileName=path;
fileName.append(g_model.bitmap);
fileName.append(".BMP");
image.load(fileName);
}
if (!image.isNull()) {
ui->modelImage_image->setPixmap(QPixmap::fromImage(image.scaled( 64,32)));;
}
}
}
modelImageLock=false;
}
if (!GetEepromInterface()->getCapability(pmSwitchMask)) {
for (int i=0; pmsl[i]; i++) {
pmsl[i]->hide();
}
for (int i=0; pmchkb[i]; i++) {
pmchkb[i]->hide();
}
ui->tswwarn0_CB->hide();
for (int i=0; tpmsld[i]; i++) {
tpmsld[i]->hide();
}
ui->swwarn0_line->hide();
ui->swwarn0_line->hide();
ui->swwarn0_CB->hide();
ui->swwarn4_CB->hide();
ui->swwarn_line0->hide();
ui->swwarn_line1->hide();
ui->swwarn_line2->hide();
ui->swwarn_line3->hide();
ui->swwarn_line4->hide();
ui->swwarn_line5->hide();
ui->tswwarn0_label->hide();
ui->tswwarn1_label->hide();
ui->tswwarn2_label->hide();
ui->tswwarn3_label->hide();
ui->tswwarn4_label->hide();
ui->tswwarn5_label->hide();
ui->tswwarn6_label->hide();
ui->tswwarn7_label->hide();
} else {
if (GetEepromInterface()->getCapability(Pots)==3) {
ui->swwarn0_CB->setCurrentIndex(g_model.switchWarningStates & 0x01);
ui->swwarn1_ChkB->setChecked(checkbit(g_model.switchWarningStates, 1));
ui->swwarn2_ChkB->setChecked(checkbit(g_model.switchWarningStates, 2));
ui->swwarn3_ChkB->setChecked(checkbit(g_model.switchWarningStates, 3));
ui->swwarn4_CB->setCurrentIndex((g_model.switchWarningStates & 0x30)>>4);
ui->swwarn5_ChkB->setChecked(checkbit(g_model.switchWarningStates, 6));
ui->swwarn6_ChkB->setChecked(checkbit(g_model.switchWarningStates, 7));
for (int i=0; pmchkb[i]; i++) {
connect(pmchkb[i], SIGNAL(stateChanged(int)),this,SLOT(startupSwitchEdited()));
}
connect(ui->swwarn0_CB,SIGNAL(currentIndexChanged(int)),this,SLOT(startupSwitchEdited()));
connect(ui->swwarn4_CB,SIGNAL(currentIndexChanged(int)),this,SLOT(startupSwitchEdited()));
} else {
ui->tswwarn0_CB->setCurrentIndex(g_model.switchWarningStates & 0x01);
uint16_t switchstate=(g_model.switchWarningStates>>1);
ui->chkSA->setValue(switchstate & 0x3);
switchstate >>= 2;
ui->chkSB->setValue(switchstate & 0x3);
switchstate >>= 2;
ui->chkSC->setValue(switchstate & 0x3);
switchstate >>= 2;
ui->chkSD->setValue(switchstate & 0x3);
switchstate >>= 2;
ui->chkSE->setValue(switchstate & 0x3);
switchstate >>= 2;
ui->chkSF->setValue((switchstate & 0x3)/2);
switchstate >>= 2;
ui->chkSG->setValue(switchstate & 0x3);
connect(ui->tswwarn0_CB,SIGNAL(currentIndexChanged(int)),this,SLOT(startupSwitchEdited()));
for (int i=0; tpmsld[i]; i++) {
connect(tpmsld[i], SIGNAL(valueChanged(int)),this,SLOT(startupSwitchEdited()));
}
}
}
int ppmmax=GetEepromInterface()->getCapability(PPMFrameLength);
if (ppmmax>0) {
ui->ppmFrameLengthDSB->setMaximum(ppmmax);
}
if (!GetEepromInterface()->getCapability(InstantTrimSW)) {
ui->instantTrim_label->hide();
ui->instantTrim_CB->setDisabled(true);
ui->instantTrim_CB->hide();
} else {
switchEditLock=true;
int found=false;
for (int i=0; i< C9X_MAX_CUSTOM_FUNCTIONS; i++) {
if (g_model.funcSw[i].func==FuncInstantTrim) {
populateSwitchCB(ui->instantTrim_CB,g_model.funcSw[i].swtch,POPULATE_MSWITCHES & POPULATE_ONOFF);
found=true;
break;
}
}
if (found==false) {
populateSwitchCB(ui->instantTrim_CB,RawSwitch(),POPULATE_MSWITCHES & POPULATE_ONOFF);
}
switchEditLock=false;
}
if (GetEepromInterface()->getCapability(NoTimerDirs)) {
ui->timer1DirCB->hide();
ui->timer2DirCB->hide();
}
if (GetEepromInterface()->getCapability(NoThrExpo)) {
ui->label_thrExpo->hide();
ui->thrExpoChkB->hide();
}
if (!(GetEepromInterface()->getCapability(ExtendedTrims)>0)) {
ui->extendedTrimsChkB->hide();
ui->extendedTrims_label->hide();
}
if (!GetEepromInterface()->getCapability(HasTTrace)) {
ui->label_ttrace->hide();
ui->ttraceCB->hide();
} else {
populateTTraceCB(ui->ttraceCB,g_model.thrTraceSrc);
}
if (GetEepromInterface()->getCapability(RotaryEncoders)==0) {
ui->bcREaChkB->hide();
ui->bcREbChkB->hide();
}
if (GetEepromInterface()->getCapability(Pots)==3) {
ui->tswwarn0_CB->hide();
ui->tswwarn0_label->hide();
ui->tswwarn1_label->hide();
ui->tswwarn2_label->hide();
ui->tswwarn3_label->hide();
ui->tswwarn4_label->hide();
ui->tswwarn5_label->hide();
ui->tswwarn6_label->hide();
ui->tswwarn7_label->hide();
ui->chkSA->hide();
ui->chkSB->hide();
ui->chkSC->hide();
ui->chkSD->hide();
ui->chkSE->hide();
ui->chkSF->hide();
ui->chkSG->hide();
this->layout()->removeItem(ui->TaranisSwitchStartup);
ui->bcP4ChkB->hide();
} else {
ui->swwarn0_CB->hide();
ui->swwarn0_label->hide();
ui->swwarn0_line->hide();
ui->swwarn1_ChkB->hide();
ui->swwarn1_line->hide();
ui->swwarn2_ChkB->hide();
ui->swwarn3_ChkB->hide();
ui->swwarn4_CB->hide();
ui->swwarn4_label->hide();
ui->swwarn5_ChkB->hide();
ui->swwarn6_ChkB->hide();
ui->swwarn_line0->hide();
ui->swwarn_line1->hide();
ui->swwarn_line2->hide();
ui->swwarn_line3->hide();
ui->swwarn_line4->hide();
ui->swwarn_line5->hide();
this->layout()->removeItem(ui->StockSwitchStartup);
ui->bcP1ChkB->setText(tr("S1"));
ui->bcP2ChkB->setText(tr("S2"));
ui->bcP3ChkB->setText(tr("LS"));
}
if (!GetEepromInterface()->getCapability(PerModelThrottleWarning)) {
ui->thrwarnChkB->setDisabled(true);
ui->thrwarnChkB->hide();
ui->thrwarnLabel->hide();
} else {
switchEditLock=true;
ui->thrwarnChkB->setChecked(g_model.disableThrottleWarning);
switchEditLock=false;
}
if (!GetEepromInterface()->getCapability(TimerTriggerB)) {
ui->timer1ModeBCB->hide();
ui->timer1ModeB_label->hide();
ui->timer2ModeBCB->hide();
ui->timer2ModeB_label->hide();
} else {
populateTimerSwitchBCB(ui->timer1ModeBCB,g_model.timers[0].modeB,GetEepromInterface()->getCapability(TimerTriggerB));
populateTimerSwitchBCB(ui->timer2ModeBCB,g_model.timers[1].modeB,GetEepromInterface()->getCapability(TimerTriggerB));
}
int index=0;
int selindex;
int selindex2;
protocolEditLock=true;
protocol2EditLock=true;
ui->protocolCB->clear();
for (int i=0; i<PROTO_LAST; i++) {
if (GetEepromInterface()->isAvailable((Protocol)i)) {
ui->protocolCB->addItem(getProtocolStr(i), (QVariant)i);
if (g_model.moduleData[0].protocol == i) {
selindex = index;
}
index++;
}
}
if (GetEepromInterface()->getCapability(NumModules)>1) {
index=0;
ui->protocolCB_2->clear();
for (int i=0; i<PROTO_LAST; ++i) {
if (GetEepromInterface()->isAvailable((Protocol)i, 1)) {
ui->protocolCB_2->addItem(getProtocolStr(i), (QVariant)i);
if (g_model.moduleData[1].protocol == i) {
selindex2 = index;
}
index++;
}
}
}
if (GetEepromInterface()->getCapability(ModelTrainerEnable)) {
trainerEditLock=true;
if (!(g_model.trainerMode||g_model.traineron)) {
ui->protocolCB_3->setCurrentIndex(0);
ui->label_PPM_3->hide();
ui->ppmDelaySB_3->hide();
ui->label_PPMCH_3->hide();
ui->label_pulsePol_3->hide();
ui->pulsePolCB_3->hide();
ui->numChannelsSB_3->hide();
ui->label_ppmFrameLength_3->hide();
ui->ppmFrameLengthDSB_3->hide();
ui->label_numChannelsStart_3->hide();
ui->numChannelsStart_3->hide();
} else {
ui->protocolCB_3->setCurrentIndex(1);
ui->label_PPM_3->show();
ui->ppmDelaySB_3->show();
ui->label_PPMCH_3->show();
ui->label_pulsePol_3->show();
ui->pulsePolCB_3->show();
ui->numChannelsSB_3->show();
ui->label_ppmFrameLength_3->show();
ui->ppmFrameLengthDSB_3->show();
ui->label_numChannelsStart_3->show();
ui->numChannelsStart_3->show();
}
trainerEditLock=false;
on_protocolCB_3_currentIndexChanged(g_model.traineron||g_model.trainerMode);
} else {
ui->rf3_GB->hide();
}
ui->label_PPM->hide();
ui->ppmDelaySB->hide();
ui->label_PPMCH->hide();
ui->label_pulsePol->hide();
ui->pulsePolCB->hide();
ui->numChannelsSB->hide();
ui->label_ppmFrameLength->hide();
ui->ppmFrameLengthDSB->hide();
ui->label_DSM->hide();
ui->DSM_Type->hide();
ui->label_PXX->hide();
ui->pxxRxNum->hide();
ui->label_numChannelsStart->hide();
ui->numChannelsStart->hide();
ui->pxxRxNum->setEnabled(false);
ui->protocolCB->setCurrentIndex(selindex);
protocolEditLock=false;
on_protocolCB_currentIndexChanged(selindex);
if (GetEepromInterface()->getCapability(NumModules)>1) {
ui->label_PPM_2->hide();
ui->ppmDelaySB_2->hide();
ui->label_PPMCH_2->hide();
ui->label_pulsePol_2->hide();
ui->pulsePolCB_2->hide();
ui->numChannelsSB_2->hide();
ui->label_ppmFrameLength_2->hide();
ui->ppmFrameLengthDSB_2->hide();
ui->label_DSM_2->hide();
ui->DSM_Type_2->hide();
ui->label_PXX_2->hide();
ui->pxxRxNum_2->hide();
ui->label_numChannelsStart_2->hide();
ui->numChannelsStart_2->hide();
ui->pxxRxNum_2->setEnabled(false);
ui->protocolCB_2->setCurrentIndex(selindex2);
protocol2EditLock=false;
on_protocolCB_2_currentIndexChanged(selindex2);
}
//timer2 mode direction value
if (GetEepromInterface()->getCapability(Timers)<2) {
ui->timer2DirCB->hide();
ui->timer2ValTE->hide();
ui->timer2DirCB->hide();
ui->timer2ModeCB->hide();
ui->timer2ModeBCB->hide();
ui->timer2ModeB_label->hide();
ui->label_timer2->hide();
} else {
populateTimerSwitchCB(ui->timer2ModeCB,g_model.timers[1].mode,GetEepromInterface()->getCapability(TimerTriggerB));
min = g_model.timers[1].val/60;
sec = g_model.timers[1].val%60;
ui->timer2ValTE->setTime(QTime(0,min,sec));
ui->timer2DirCB->setCurrentIndex(g_model.timers[1].dir);
}
if (!GetEepromInterface()->getCapability(PermTimers)) {
ui->timer1Perm->hide();
ui->timer2Perm->hide();
ui->timer1PermValue->hide();
ui->timer2PermValue->hide();
} else {
int sign=1;
int pvalue=g_model.timers[0].pvalue;
if (pvalue<0) {
pvalue=-pvalue;
sign=-1;
}
int hours=pvalue/3600;
pvalue-=hours*3600;
int minutes = pvalue/60;
int seconds = pvalue%60;
ui->timer1PermValue->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')));
// QString QString::arg ( int a, int fieldWidth = 0, int base = 10, const QChar & fillChar = QLatin1Char( ' ' ) ) const
sign=1;
pvalue=g_model.timers[1].pvalue;
if (pvalue<0) {
pvalue=-pvalue;
sign=-1;
}
hours=pvalue/3600;
pvalue-=hours*3600;
minutes = pvalue/60;
seconds = pvalue%60;
ui->timer2PermValue->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->timer1Perm->setChecked(g_model.timers[0].persistent);
ui->timer2Perm->setChecked(g_model.timers[1].persistent);
}
if (!GetEepromInterface()->getCapability(minuteBeep)) {
ui->timer1Minute->hide();
ui->timer2Minute->hide();
} else {
ui->timer1Minute->setChecked(g_model.timers[0].minuteBeep);
ui->timer2Minute->setChecked(g_model.timers[1].minuteBeep);
}
if (!GetEepromInterface()->getCapability(countdownBeep)) {
ui->timer1CountDownBeep->hide();
ui->timer2CountDownBeep->hide();
} else {
ui->timer1CountDownBeep->setChecked(g_model.timers[0].countdownBeep);
ui->timer2CountDownBeep->setChecked(g_model.timers[1].countdownBeep);
}
//trim inc, thro trim, thro expo, instatrim
ui->trimIncCB->setCurrentIndex(g_model.trimInc);
ui->thrExpoChkB->setChecked(g_model.thrExpo);
ui->thrTrimChkB->setChecked(g_model.thrTrim);
//center beep
ui->bcRUDChkB->setChecked(g_model.beepANACenter & BC_BIT_RUD);
ui->bcELEChkB->setChecked(g_model.beepANACenter & BC_BIT_ELE);
ui->bcTHRChkB->setChecked(g_model.beepANACenter & BC_BIT_THR);
ui->bcAILChkB->setChecked(g_model.beepANACenter & BC_BIT_AIL);
ui->bcP1ChkB->setChecked(g_model.beepANACenter & BC_BIT_P1);
ui->bcP2ChkB->setChecked(g_model.beepANACenter & BC_BIT_P2);
ui->bcP3ChkB->setChecked(g_model.beepANACenter & BC_BIT_P3);
ui->bcP4ChkB->setChecked(g_model.beepANACenter & BC_BIT_P4);
ui->bcREaChkB->setChecked(g_model.beepANACenter & BC_BIT_REA);
ui->bcREbChkB->setChecked(g_model.beepANACenter & BC_BIT_REB);
// PPM settings fields
ui->ppmDelaySB->setEnabled(g_model.moduleData[0].protocol == PPM);
ui->pulsePolCB->setCurrentIndex(g_model.moduleData[0].ppmPulsePol);
ui->ppmDelaySB->setEnabled(g_model.moduleData[0].protocol == PPM);
ui->ppmDelaySB->setValue(g_model.moduleData[0].ppmDelay);
// TODO? ui->numChannelsSB->setEnabled(g_model.moduleData[0].protocol == PPM);
ui->extendedLimitsChkB->setChecked(g_model.extendedLimits);
ui->T2ThrTrgChkB->setChecked(g_model.t2throttle);
if (!GetEepromInterface()->getCapability(Timer2ThrTrig)) {
ui->T2ThrTrg->hide();
ui->T2ThrTrgChkB->hide();
}
ui->ppmFrameLengthDSB->setValue(22.5+((double)g_model.moduleData[0].ppmFrameLength)*0.5);
if (!GetEepromInterface()->getCapability(PPMExtCtrl)) {
ui->ppmFrameLengthDSB->hide();
ui->label_ppmFrameLength->hide();
}
switch (g_model.moduleData[0].protocol) {
case PXX_DJT:
case PXX_XJT_X16:
case PXX_XJT_D8:
case PXX_XJT_LR12:
ui->pxxRxNum->setMinimum(0);
ui->pxxRxNum->setValue((g_model.modelId));
break;
case DSM2:
if (!GetEepromInterface()->getCapability(DSM2Indexes)) {
ui->pxxRxNum->setValue(1);
}
else {
ui->pxxRxNum->setMinimum(0);
ui->pxxRxNum->setValue((g_model.modelId));
}
ui->numChannelsSB->setValue(8);
break;
default:
ui->label_DSM->hide();
ui->DSM_Type->hide();
ui->DSM_Type->setEnabled(false);
ui->label_PXX->hide();
ui->pxxRxNum->hide();
ui->pxxRxNum->setEnabled(false);
ui->numChannelsSB->setValue(g_model.moduleData[0].channelsCount);
break;
}
}
void ModelEdit::on_modelVoice_SB_editingFinished()
{
g_model.modelVoice=ui->modelVoice_SB->value()-260;
updateSettings();
}
void ModelEdit::on_timer1Perm_toggled(bool checked)
{
g_model.timers[0].persistent=checked;
updateSettings();
}
void ModelEdit::on_timer2Perm_toggled(bool checked)
{
g_model.timers[1].persistent=checked;
updateSettings();
}
void ModelEdit::on_timer1Minute_toggled(bool checked)
{
g_model.timers[0].minuteBeep=checked;
updateSettings();
}
void ModelEdit::on_timer2Minute_toggled(bool checked)
{
g_model.timers[1].minuteBeep=checked;
updateSettings();
}
void ModelEdit::on_timer1CountDownBeep_toggled(bool checked)
{
g_model.timers[0].countdownBeep=checked;
updateSettings();
}
void ModelEdit::on_timer2CountDownBeep_toggled(bool checked)
{
g_model.timers[1].countdownBeep=checked;
updateSettings();
}
void ModelEdit::displayOnePhaseOneTrim(unsigned int phase_idx, unsigned int chn, QComboBox *trimUse, QSpinBox *trimVal, QSlider *trimSlider)
{
PhaseData *phase = &g_model.phaseData[phase_idx];
int trim = phase->trim[chn];
if (trimUse) populateTrimUseCB(trimUse, phase_idx);
if (phase->trimRef[chn] >= 0) {
if (trimUse) trimUse->setCurrentIndex(1 + phase->trimRef[chn] - (phase->trimRef[chn] >= (int)phase_idx ? 1 : 0));
trim = g_model.phaseData[g_model.getTrimFlightPhase(chn, phase_idx)].trim[chn];
trimVal->setEnabled(false);
trimSlider->setEnabled(false);
} else {
trimVal->setEnabled(true);
trimSlider->setEnabled(true);
if (trimUse) trimUse->setCurrentIndex(0);
}
int trimsMax = GetEepromInterface()->getCapability(ExtendedTrims);
if (trimsMax == 0 || !g_model.extendedTrims) {
trimsMax = 125;
}
/*else if (trimsMax == 500)
trimSlider->setTickInterval(50);*/
trimSlider->setRange(-trimsMax, +trimsMax);
trimVal->setRange(-trimsMax, +trimsMax);
trimVal->setValue(trim);
trimSlider->setValue(trim);
if (chn == 2 && g_eeGeneral.throttleReversed)
trimSlider->setInvertedAppearance(true);
}
void ModelEdit::displayOnePhase(unsigned int phase_idx, QLineEdit *name, QComboBox *sw, QDoubleSpinBox *fadeIn, QDoubleSpinBox *fadeOut,
QComboBox *trim1Use, QSpinBox *trim1, QLabel *trim1Label, QSlider *trim1Slider,
QComboBox *trim2Use, QSpinBox *trim2, QLabel *trim2Label, QSlider *trim2Slider,
QComboBox *trim3Use, QSpinBox *trim3, QLabel *trim3Label, QSlider *trim3Slider,
QComboBox *trim4Use, QSpinBox *trim4, QLabel *trim4Label, QSlider *trim4Slider,
QLabel *gv1Label, QComboBox *gv1Use,QSpinBox *gv1Value,
QLabel *gv2Label, QComboBox *gv2Use,QSpinBox *gv2Value,
QLabel *gv3Label, QComboBox *gv3Use,QSpinBox *gv3Value,
QLabel *gv4Label, QComboBox *gv4Use,QSpinBox *gv4Value,
QLabel *gv5Label, QComboBox *gv5Use,QSpinBox *gv5Value,
QLabel *re1Label, QComboBox *re1Use,QSpinBox *re1Value,
QLabel *re2Label, QComboBox *re2Use,QSpinBox *re2Value,bool doConnect=false)
{
phasesLock=true;
PhaseData *phase = &g_model.phaseData[phase_idx];
if (IS_TARANIS(GetEepromInterface()->getBoard())) {
if (name) name->setMaxLength(10);
} else {
if (name) name->setMaxLength(6);
}
if (name) name->setText(phase->name);
if (sw) populateSwitchCB(sw, phase->swtch);
int scale=GetEepromInterface()->getCapability(SlowScale);
float range=GetEepromInterface()->getCapability(SlowRange);
int fades=GetEepromInterface()->getCapability(FlightPhasesHaveFades);
if (fades && fadeIn) {
fadeIn->setEnabled(true);
fadeOut->setEnabled(true);
fadeIn->setMaximum(range/scale);
fadeIn->setSingleStep(1.0/scale);
fadeIn->setDecimals((scale==1 ? 0 :1) );
if (fadeIn) {
fadeIn->setValue((double)phase->fadeIn/scale);
}
fadeOut->setMaximum(range/scale);
fadeOut->setSingleStep(1.0/scale);
fadeOut->setDecimals((scale==1 ? 0 :1));
if (fadeOut) {
fadeOut->setValue((double)phase->fadeOut/scale);
}
} else if ( fadeIn ) {
fadeIn->setDisabled(true);
fadeOut->setDisabled(true);
}
displayOnePhaseOneTrim(phase_idx, CONVERT_MODE(1)-1, trim1Use, trim1, trim1Slider);
displayOnePhaseOneTrim(phase_idx, CONVERT_MODE(2)-1, trim2Use, trim2, trim2Slider);
displayOnePhaseOneTrim(phase_idx, CONVERT_MODE(3)-1, trim3Use, trim3, trim3Slider);
displayOnePhaseOneTrim(phase_idx, CONVERT_MODE(4)-1, trim4Use, trim4, trim4Slider);
if (gv1Use) {
populateGvarUseCB(gv1Use, phase_idx);
if (phase->gvars[0]>1024) {
gv1Use->setCurrentIndex(phase->gvars[0]-1024);
}
}
gv1Value->setMinimum(-1024);
gv1Value->setMaximum(1024);
if (phase->gvars[0]<1024) {
gv1Value->setValue(phase->gvars[0]);
gv1Value->setEnabled(true);
} else {
uint index=phase->gvars[0]-1025;
if (index>=phase_idx) {
index++;
}
PhaseData *phasegvar = &g_model.phaseData[index];
gv1Value->setValue(phasegvar->gvars[0]);
gv1Value->setDisabled(true);
}
if (gv2Use) {
populateGvarUseCB(gv2Use, phase_idx);
if (phase->gvars[1]>1024) {
gv2Use->setCurrentIndex(phase->gvars[1]-1024);
}
}
gv2Value->setMinimum(-1024);
gv2Value->setMaximum(1024);
if (phase->gvars[1]<1024) {
gv2Value->setValue(phase->gvars[1]);
gv2Value->setEnabled(true);
} else {
uint index=phase->gvars[1]-1025;
if (index>=phase_idx) {
index++;
}
PhaseData *phasegvar = &g_model.phaseData[index];
gv2Value->setValue(phasegvar->gvars[1]);
gv2Value->setDisabled(true);
}
if (gv3Use) {
populateGvarUseCB(gv3Use, phase_idx);
if (phase->gvars[2]>1024) {
gv3Use->setCurrentIndex(phase->gvars[2]-1024);
}
}
gv3Value->setMinimum(-1024);
gv3Value->setMaximum(1024);
if (phase->gvars[2]<1024) {
gv3Value->setValue(phase->gvars[2]);
gv3Value->setEnabled(true);
} else {
uint index=phase->gvars[2]-1025;
if (index>=phase_idx) {
index++;
}
PhaseData *phasegvar = &g_model.phaseData[index];
gv3Value->setValue(phasegvar->gvars[2]);
gv3Value->setDisabled(true);
}
if (gv4Use) {
populateGvarUseCB(gv4Use, phase_idx);
if (phase->gvars[3]>1024) {
gv4Use->setCurrentIndex(phase->gvars[3]-1024);
}
}
gv4Value->setMinimum(-1024);
gv4Value->setMaximum(1024);
if (phase->gvars[3]<1024) {
gv4Value->setValue(phase->gvars[3]);
gv4Value->setEnabled(true);
} else {
uint index=phase->gvars[3]-1025;
if (index>=phase_idx) {
index++;
}
PhaseData *phasegvar = &g_model.phaseData[index];
gv4Value->setValue(phasegvar->gvars[3]);
gv4Value->setDisabled(true);
}
if (gv5Use) {
populateGvarUseCB(gv5Use, phase_idx);
if (phase->gvars[4]>1024) {
gv5Use->setCurrentIndex(phase->gvars[4]-1024);
}
}
gv5Value->setMinimum(-1024);
gv5Value->setMaximum(1024);
if (phase->gvars[4]<1024) {
gv5Value->setValue(phase->gvars[4]);
gv5Value->setEnabled(true);
} else {
uint index=phase->gvars[4]-1025;
if (index>=phase_idx) {
index++;
}
PhaseData *phasegvar = &g_model.phaseData[index];
gv5Value->setValue(phasegvar->gvars[4]);
gv5Value->setDisabled(true);
}
if (re1Value) {
re1Value->setMinimum(-1024);
re1Value->setMaximum(1024);
}
if (re2Value) {
re2Value->setMinimum(-1024);
re2Value->setMaximum(1024);
}
if (re1Use) {
populateGvarUseCB(re1Use, phase_idx);
if (phase->rotaryEncoders[0]>1024) {
re1Use->setCurrentIndex(phase->rotaryEncoders[0]-1024);
}
}
if (phase->rotaryEncoders[0]<1024) {
re1Value->setValue(phase->rotaryEncoders[0]);
re1Value->setEnabled(true);
} else {
uint index=phase->rotaryEncoders[0]-1025;
if (index>=phase_idx) {
index++;
}
PhaseData *phasegvar = &g_model.phaseData[index];
re1Value->setValue(phasegvar->rotaryEncoders[0]);
re1Value->setDisabled(true);
}
if (re2Use) {
populateGvarUseCB(re2Use, phase_idx);
if (phase->rotaryEncoders[0]>1024) {
re1Use->setCurrentIndex(phase->rotaryEncoders[0]-1024);
}
}
if (phase->rotaryEncoders[1]<1024) {
re2Value->setValue(phase->rotaryEncoders[1]);
re2Value->setEnabled(true);
} else {
uint index=phase->rotaryEncoders[1]-1025;
if (index>=phase_idx) {
index++;
}
PhaseData *phasegvar = &g_model.phaseData[index];
re2Value->setValue(phasegvar->rotaryEncoders[1]);
re2Value->setDisabled(true);
}
if (GetEepromInterface()->getCapability(RotaryEncoders)<2) {
if (re2Label)
re2Label->hide();
if (re2Use)
re2Use->hide();
re2Value->hide();
}
if (GetEepromInterface()->getCapability(RotaryEncoders)<1) {
if (re1Label)
re1Label->hide();
if (re1Use)
re1Use->hide();
re1Value->hide();
}
QString labels[] = { tr("Rud"), tr("Ele"), tr("Thr"), tr("Ail") };
if (trim1Label) {
trim1Label->setText(labels[CONVERT_MODE(1)-1]);
trim2Label->setText(labels[CONVERT_MODE(2)-1]);
trim3Label->setText(labels[CONVERT_MODE(3)-1]);
trim4Label->setText(labels[CONVERT_MODE(4)-1]);
}
// the connects
if (doConnect) {
connect(name, SIGNAL(editingFinished()), this, SLOT(phaseName_editingFinished()));
if (sw!=NULL) {
connect(sw,SIGNAL(currentIndexChanged(int)),this,SLOT(phaseSwitch_currentIndexChanged()));
connect(trim1Use,SIGNAL(currentIndexChanged(int)),this,SLOT(phaseTrimUse_currentIndexChanged()));
connect(trim2Use,SIGNAL(currentIndexChanged(int)),this,SLOT(phaseTrimUse_currentIndexChanged()));
connect(trim3Use,SIGNAL(currentIndexChanged(int)),this,SLOT(phaseTrimUse_currentIndexChanged()));
connect(trim4Use,SIGNAL(currentIndexChanged(int)),this,SLOT(phaseTrimUse_currentIndexChanged()));
}
if (gv1Use) connect(gv1Use,SIGNAL(currentIndexChanged(int)),this,SLOT(phaseGVUse_currentIndexChanged()));
if (gv2Use) connect(gv2Use,SIGNAL(currentIndexChanged(int)),this,SLOT(phaseGVUse_currentIndexChanged()));
if (gv3Use) connect(gv3Use,SIGNAL(currentIndexChanged(int)),this,SLOT(phaseGVUse_currentIndexChanged()));
if (gv4Use) connect(gv4Use,SIGNAL(currentIndexChanged(int)),this,SLOT(phaseGVUse_currentIndexChanged()));
if (gv5Use) connect(gv5Use,SIGNAL(currentIndexChanged(int)),this,SLOT(phaseGVUse_currentIndexChanged()));
if (re1Use) connect(re1Use,SIGNAL(currentIndexChanged(int)),this,SLOT(phaseREUse_currentIndexChanged()));
if (re2Use) connect(re2Use,SIGNAL(currentIndexChanged(int)),this,SLOT(phaseREUse_currentIndexChanged()));
connect(gv1Value,SIGNAL(editingFinished()),this,SLOT(phaseGVValue_editingFinished()));
connect(gv2Value,SIGNAL(editingFinished()),this,SLOT(phaseGVValue_editingFinished()));
connect(gv3Value,SIGNAL(editingFinished()),this,SLOT(phaseGVValue_editingFinished()));
connect(gv4Value,SIGNAL(editingFinished()),this,SLOT(phaseGVValue_editingFinished()));
connect(gv5Value,SIGNAL(editingFinished()),this,SLOT(phaseGVValue_editingFinished()));
connect(re1Value,SIGNAL(editingFinished()),this,SLOT(phaseREValue_editingFinished()));
connect(re2Value,SIGNAL(editingFinished()),this,SLOT(phaseREValue_editingFinished()));
connect(fadeIn,SIGNAL(editingFinished()),this,SLOT(phaseFadeIn_editingFinished()));
connect(fadeOut,SIGNAL(editingFinished()),this,SLOT(phaseFadeOut_editingFinished()));
connect(trim1,SIGNAL(valueChanged(int)),this,SLOT(phaseTrim_valueChanged()));
connect(trim2,SIGNAL(valueChanged(int)),this,SLOT(phaseTrim_valueChanged()));
connect(trim3,SIGNAL(valueChanged(int)),this,SLOT(phaseTrim_valueChanged()));
connect(trim4,SIGNAL(valueChanged(int)),this,SLOT(phaseTrim_valueChanged()));
connect(trim1Slider,SIGNAL(valueChanged(int)),this,SLOT(phaseTrimSlider_valueChanged()));
connect(trim2Slider,SIGNAL(valueChanged(int)),this,SLOT(phaseTrimSlider_valueChanged()));
connect(trim3Slider,SIGNAL(valueChanged(int)),this,SLOT(phaseTrimSlider_valueChanged()));
connect(trim4Slider,SIGNAL(valueChanged(int)),this,SLOT(phaseTrimSlider_valueChanged()));
phasesLock=false;
}
}
void ModelEdit::tabPhases()
{
QSpinBox * tmp[9][5]={
{ui->phase0GV1Value,ui->phase0GV2Value,ui->phase0GV3Value,ui->phase0GV4Value,ui->phase0GV5Value} ,
{ui->phase1GV1Value,ui->phase1GV2Value,ui->phase1GV3Value,ui->phase1GV4Value,ui->phase1GV5Value} ,
{ui->phase2GV1Value,ui->phase2GV2Value,ui->phase2GV3Value,ui->phase2GV4Value,ui->phase2GV5Value} ,
{ui->phase3GV1Value,ui->phase3GV2Value,ui->phase3GV3Value,ui->phase3GV4Value,ui->phase3GV5Value} ,
{ui->phase4GV1Value,ui->phase4GV2Value,ui->phase4GV3Value,ui->phase4GV4Value,ui->phase4GV5Value} ,
{ui->phase5GV1Value,ui->phase5GV2Value,ui->phase5GV3Value,ui->phase5GV4Value,ui->phase5GV5Value} ,
{ui->phase6GV1Value,ui->phase6GV2Value,ui->phase6GV3Value,ui->phase6GV4Value,ui->phase6GV5Value} ,
{ui->phase7GV1Value,ui->phase7GV2Value,ui->phase7GV3Value,ui->phase7GV4Value,ui->phase7GV5Value} ,
{ui->phase8GV1Value,ui->phase8GV2Value,ui->phase8GV3Value,ui->phase8GV4Value,ui->phase8GV5Value}
};
QSpinBox * tmp2[9][2]={
{ui->phase0RE1Value,ui->phase0RE2Value} ,
{ui->phase1RE1Value,ui->phase1RE2Value} ,
{ui->phase2RE1Value,ui->phase2RE2Value} ,
{ui->phase3RE1Value,ui->phase3RE2Value} ,
{ui->phase4RE1Value,ui->phase4RE2Value} ,
{ui->phase5RE1Value,ui->phase5RE2Value} ,
{ui->phase6RE1Value,ui->phase6RE2Value} ,
{ui->phase7RE1Value,ui->phase7RE2Value} ,
{ui->phase8RE1Value,ui->phase8RE2Value} ,
};
memcpy(gvarsSB, tmp, sizeof(gvarsSB));
memcpy(reSB, tmp2, sizeof(reSB));
phasesLock = true;
int gvars=0;
if (GetEepromInterface()->getCapability(HasVariants)) {
if (GetCurrentFirmwareVariant() & GVARS_VARIANT)
gvars=1;
} else {
gvars=GetEepromInterface()->getCapability(Gvars);
}
if (!GetEepromInterface()->getCapability(RotaryEncoders)) {
ui->phase0reGB->hide();
ui->phase1reGB->hide();
ui->phase2reGB->hide();
ui->phase3reGB->hide();
ui->phase4reGB->hide();
ui->phase5reGB->hide();
ui->phase6reGB->hide();
ui->phase7reGB->hide();
ui->phase8reGB->hide();
}
if (!GetEepromInterface()->getCapability(GvarsFlightPhases) || gvars==0) {
if (!GetEepromInterface()->getCapability(Gvars) || gvars==0) {
ui->phase0gvGB->hide();
}
ui->phase1gvGB->hide();
ui->phase2gvGB->hide();
ui->phase3gvGB->hide();
ui->phase4gvGB->hide();
ui->phase5gvGB->hide();
ui->phase6gvGB->hide();
ui->phase7gvGB->hide();
ui->phase8gvGB->hide();
}
if (!GetEepromInterface()->getCapability(GvarsAreNamed)) {
ui->phase0GV1Name->hide();
ui->phase0GV2Name->hide();
ui->phase0GV3Name->hide();
ui->phase0GV4Name->hide();
ui->phase0GV5Name->hide();
ui->phase0GV6Name->hide();
ui->phase0GV7Name->hide();
}
if (GetEepromInterface()->getCapability(Gvars) && gvars==1) {
if (!GetEepromInterface()->getCapability(GvarsHaveSources)) {
ui->phase0GV1Source->hide();
ui->phase0GV2Source->hide();
ui->phase0GV3Source->hide();
ui->phase0GV4Source->hide();
ui->phase0GV5Source->hide();
ui->phase0GV6Source->hide();
ui->phase0GV7Source->hide();
} else {
populateGvSourceCB(ui->phase0GV1Source, g_model.gvsource[0]);
populateGvSourceCB(ui->phase0GV2Source, g_model.gvsource[1]);
populateGvSourceCB(ui->phase0GV3Source, g_model.gvsource[2]);
populateGvSourceCB(ui->phase0GV4Source, g_model.gvsource[3]);
populateGvSourceCB(ui->phase0GV5Source, g_model.gvsource[4]);
connect(ui->phase0GV1Source,SIGNAL(currentIndexChanged(int)),this,SLOT(GVSource_currentIndexChanged()));
connect(ui->phase0GV2Source,SIGNAL(currentIndexChanged(int)),this,SLOT(GVSource_currentIndexChanged()));
connect(ui->phase0GV3Source,SIGNAL(currentIndexChanged(int)),this,SLOT(GVSource_currentIndexChanged()));
connect(ui->phase0GV4Source,SIGNAL(currentIndexChanged(int)),this,SLOT(GVSource_currentIndexChanged()));
connect(ui->phase0GV5Source,SIGNAL(currentIndexChanged(int)),this,SLOT(GVSource_currentIndexChanged()));
}
if (IS_TARANIS(GetEepromInterface()->getBoard())) {
ui->phase0GV1Name->setMaxLength(10);
ui->phase0GV2Name->setMaxLength(10);
ui->phase0GV3Name->setMaxLength(10);
ui->phase0GV4Name->setMaxLength(10);
ui->phase0GV5Name->setMaxLength(10);
} else {
ui->phase0GV1Name->setMaxLength(6);
ui->phase0GV2Name->setMaxLength(6);
ui->phase0GV3Name->setMaxLength(6);
ui->phase0GV4Name->setMaxLength(6);
ui->phase0GV5Name->setMaxLength(6);
}
ui->phase0GV1Name->setText(g_model.gvars_names[0]);
ui->phase0GV2Name->setText(g_model.gvars_names[1]);
ui->phase0GV3Name->setText(g_model.gvars_names[2]);
ui->phase0GV4Name->setText(g_model.gvars_names[3]);
ui->phase0GV5Name->setText(g_model.gvars_names[4]);
connect(ui->phase0GV1Name,SIGNAL(editingFinished()),this,SLOT(GVName_editingFinished()));
connect(ui->phase0GV2Name,SIGNAL(editingFinished()),this,SLOT(GVName_editingFinished()));
connect(ui->phase0GV3Name,SIGNAL(editingFinished()),this,SLOT(GVName_editingFinished()));
connect(ui->phase0GV4Name,SIGNAL(editingFinished()),this,SLOT(GVName_editingFinished()));
connect(ui->phase0GV5Name,SIGNAL(editingFinished()),this,SLOT(GVName_editingFinished()));
}
if (gvars) {
if (GetEepromInterface()->getCapability(GvarsNum)<7) {
ui->phase0GV6Name->hide();
ui->phase0GV7Name->hide();
ui->phase0GV6Source->hide();
ui->phase0GV7Source->hide();
ui->phase0GV6Value->hide();
ui->phase0GV7Value->hide();
ui->phase0GV6_Label->hide();
ui->phase0GV7_Label->hide();
} else {
populateGvSourceCB(ui->phase0GV6Source, g_model.gvsource[5]);
populateGvSourceCB(ui->phase0GV7Source, g_model.gvsource[6]);
connect(ui->phase0GV6Source,SIGNAL(currentIndexChanged(int)),this,SLOT(GVSource_currentIndexChanged()));
connect(ui->phase0GV7Source,SIGNAL(currentIndexChanged(int)),this,SLOT(GVSource_currentIndexChanged()));
ui->phase0GV6Name->setText(g_model.gvars_names[5]);
ui->phase0GV7Name->setText(g_model.gvars_names[6]);
connect(ui->phase0GV6Name,SIGNAL(editingFinished()),this,SLOT(GVName_editingFinished()));
connect(ui->phase0GV7Name,SIGNAL(editingFinished()),this,SLOT(GVName_editingFinished()));
ui->phase0GV6Value->setValue(g_model.phaseData[0].gvars[5]);
ui->phase0GV7Value->setValue(g_model.phaseData[0].gvars[6]);
connect(ui->phase0GV6Value,SIGNAL(editingFinished()),this,SLOT(phaseGVValue_editingFinished()));
connect(ui->phase0GV7Value,SIGNAL(editingFinished()),this,SLOT(phaseGVValue_editingFinished()));
}
}
displayOnePhase(0, ui->phase0Name, NULL, ui->phase0FadeIn, ui->phase0FadeOut, NULL, ui->phase0Trim1Value, ui->phase0Trim1Label, ui->phase0Trim1Slider, NULL, ui->phase0Trim2Value, ui->phase0Trim2Label, ui->phase0Trim2Slider, NULL, ui->phase0Trim3Value, ui->phase0Trim3Label, ui->phase0Trim3Slider, NULL, ui->phase0Trim4Value, ui->phase0Trim4Label, ui->phase0Trim4Slider, ui->phase0GV1_Label, NULL , ui->phase0GV1Value, ui->phase0GV2_Label, NULL , ui->phase0GV2Value, ui->phase0GV3_Label, NULL , ui->phase0GV3Value, ui->phase0GV4_Label, NULL , ui->phase0GV4Value, ui->phase0GV5_Label, NULL , ui->phase0GV5Value,ui->phase0REA_Label,NULL, ui->phase0RE1Value,ui->phase0REB_Label, NULL, ui->phase0RE2Value, true);
displayOnePhase(1, ui->phase1Name, ui->phase1Switch, ui->phase1FadeIn, ui->phase1FadeOut, ui->phase1Trim1Use, ui->phase1Trim1Value, ui->phase1Trim1Label, ui->phase1Trim1Slider, ui->phase1Trim2Use, ui->phase1Trim2Value, ui->phase1Trim2Label, ui->phase1Trim2Slider, ui->phase1Trim3Use, ui->phase1Trim3Value, ui->phase1Trim3Label, ui->phase1Trim3Slider, ui->phase1Trim4Use, ui->phase1Trim4Value, ui->phase1Trim4Label, ui->phase1Trim4Slider, ui->phase1GV1_Label, ui->phase1GV1Use, ui->phase1GV1Value, ui->phase1GV2_Label, ui->phase1GV2Use, ui->phase1GV2Value, ui->phase1GV3_Label, ui->phase1GV3Use, ui->phase1GV3Value, ui->phase1GV4_Label, ui->phase1GV4Use, ui->phase1GV4Value, ui->phase1GV5_Label, ui->phase1GV5Use, ui->phase1GV5Value,ui->phase1REA_Label, ui->phase1RE1Use, ui->phase1RE1Value,ui->phase1REB_Label, ui->phase1RE2Use, ui->phase1RE2Value, true);
displayOnePhase(2, ui->phase2Name, ui->phase2Switch, ui->phase2FadeIn, ui->phase2FadeOut, ui->phase2Trim1Use, ui->phase2Trim1Value, ui->phase2Trim1Label, ui->phase2Trim1Slider, ui->phase2Trim2Use, ui->phase2Trim2Value, ui->phase2Trim2Label, ui->phase2Trim2Slider, ui->phase2Trim3Use, ui->phase2Trim3Value, ui->phase2Trim3Label, ui->phase2Trim3Slider, ui->phase2Trim4Use, ui->phase2Trim4Value, ui->phase2Trim4Label, ui->phase2Trim4Slider, ui->phase2GV1_Label, ui->phase2GV1Use, ui->phase2GV1Value, ui->phase2GV2_Label, ui->phase2GV2Use, ui->phase2GV2Value, ui->phase2GV3_Label, ui->phase2GV3Use, ui->phase2GV3Value, ui->phase2GV4_Label, ui->phase2GV4Use, ui->phase2GV4Value, ui->phase2GV5_Label, ui->phase2GV5Use, ui->phase2GV5Value,ui->phase2REA_Label, ui->phase2RE1Use, ui->phase2RE1Value,ui->phase2REB_Label, ui->phase2RE2Use, ui->phase2RE2Value, true);
displayOnePhase(3, ui->phase3Name, ui->phase3Switch, ui->phase3FadeIn, ui->phase3FadeOut, ui->phase3Trim1Use, ui->phase3Trim1Value, ui->phase3Trim1Label, ui->phase3Trim1Slider, ui->phase3Trim2Use, ui->phase3Trim2Value, ui->phase3Trim2Label, ui->phase3Trim2Slider, ui->phase3Trim3Use, ui->phase3Trim3Value, ui->phase3Trim3Label, ui->phase3Trim3Slider, ui->phase3Trim4Use, ui->phase3Trim4Value, ui->phase3Trim4Label, ui->phase3Trim4Slider, ui->phase3GV1_Label, ui->phase3GV1Use, ui->phase3GV1Value, ui->phase3GV2_Label, ui->phase3GV2Use, ui->phase3GV2Value, ui->phase3GV3_Label, ui->phase3GV3Use, ui->phase3GV3Value, ui->phase3GV4_Label, ui->phase3GV4Use, ui->phase3GV4Value, ui->phase3GV5_Label, ui->phase3GV5Use, ui->phase3GV5Value,ui->phase3REA_Label, ui->phase3RE1Use, ui->phase3RE1Value,ui->phase3REB_Label, ui->phase3RE2Use, ui->phase3RE2Value, true);
displayOnePhase(4, ui->phase4Name, ui->phase4Switch, ui->phase4FadeIn, ui->phase4FadeOut, ui->phase4Trim1Use, ui->phase4Trim1Value, ui->phase4Trim1Label, ui->phase4Trim1Slider, ui->phase4Trim2Use, ui->phase4Trim2Value, ui->phase4Trim2Label, ui->phase4Trim2Slider, ui->phase4Trim3Use, ui->phase4Trim3Value, ui->phase4Trim3Label, ui->phase4Trim3Slider, ui->phase4Trim4Use, ui->phase4Trim4Value, ui->phase4Trim4Label, ui->phase4Trim4Slider, ui->phase4GV1_Label, ui->phase4GV1Use, ui->phase4GV1Value, ui->phase4GV2_Label, ui->phase4GV2Use, ui->phase4GV2Value, ui->phase4GV3_Label, ui->phase4GV3Use, ui->phase4GV3Value, ui->phase4GV4_Label, ui->phase4GV4Use, ui->phase4GV4Value, ui->phase4GV5_Label, ui->phase4GV5Use, ui->phase4GV5Value,ui->phase4REA_Label, ui->phase4RE1Use, ui->phase4RE1Value,ui->phase4REB_Label, ui->phase4RE2Use, ui->phase4RE2Value, true);
displayOnePhase(5, ui->phase5Name, ui->phase5Switch, ui->phase5FadeIn, ui->phase5FadeOut, ui->phase5Trim1Use, ui->phase5Trim1Value, ui->phase5Trim1Label, ui->phase5Trim1Slider, ui->phase5Trim2Use, ui->phase5Trim2Value, ui->phase5Trim2Label, ui->phase5Trim2Slider, ui->phase5Trim3Use, ui->phase5Trim3Value, ui->phase5Trim3Label, ui->phase5Trim3Slider, ui->phase5Trim4Use, ui->phase5Trim4Value, ui->phase5Trim4Label, ui->phase5Trim4Slider, ui->phase5GV1_Label, ui->phase5GV1Use, ui->phase5GV1Value, ui->phase5GV2_Label, ui->phase5GV2Use, ui->phase5GV2Value, ui->phase5GV3_Label, ui->phase5GV3Use, ui->phase5GV3Value, ui->phase5GV4_Label, ui->phase5GV4Use, ui->phase5GV4Value, ui->phase5GV5_Label, ui->phase5GV5Use, ui->phase5GV5Value,ui->phase5REA_Label, ui->phase5RE1Use, ui->phase5RE1Value,ui->phase5REB_Label, ui->phase5RE2Use, ui->phase5RE2Value, true);
displayOnePhase(6, ui->phase6Name, ui->phase6Switch, ui->phase6FadeIn, ui->phase6FadeOut, ui->phase6Trim1Use, ui->phase6Trim1Value, ui->phase6Trim1Label, ui->phase6Trim1Slider, ui->phase6Trim2Use, ui->phase6Trim2Value, ui->phase6Trim2Label, ui->phase6Trim2Slider, ui->phase6Trim3Use, ui->phase6Trim3Value, ui->phase6Trim3Label, ui->phase6Trim3Slider, ui->phase6Trim4Use, ui->phase6Trim4Value, ui->phase6Trim4Label, ui->phase6Trim4Slider, ui->phase6GV1_Label, ui->phase6GV1Use, ui->phase6GV1Value, ui->phase6GV2_Label, ui->phase6GV2Use, ui->phase6GV2Value, ui->phase6GV3_Label, ui->phase6GV3Use, ui->phase6GV3Value, ui->phase6GV4_Label, ui->phase6GV4Use, ui->phase6GV4Value, ui->phase6GV5_Label, ui->phase6GV5Use, ui->phase6GV5Value,ui->phase6REA_Label, ui->phase6RE1Use, ui->phase6RE1Value,ui->phase6REB_Label, ui->phase6RE2Use, ui->phase6RE2Value, true);
displayOnePhase(7, ui->phase7Name, ui->phase7Switch, ui->phase7FadeIn, ui->phase7FadeOut, ui->phase7Trim1Use, ui->phase7Trim1Value, ui->phase7Trim1Label, ui->phase7Trim1Slider, ui->phase7Trim2Use, ui->phase7Trim2Value, ui->phase7Trim2Label, ui->phase7Trim2Slider, ui->phase7Trim3Use, ui->phase7Trim3Value, ui->phase7Trim3Label, ui->phase7Trim3Slider, ui->phase7Trim4Use, ui->phase7Trim4Value, ui->phase7Trim4Label, ui->phase7Trim4Slider, ui->phase7GV1_Label, ui->phase7GV1Use, ui->phase7GV1Value, ui->phase7GV2_Label, ui->phase7GV2Use, ui->phase7GV2Value, ui->phase7GV3_Label, ui->phase7GV3Use, ui->phase7GV3Value, ui->phase7GV4_Label, ui->phase7GV4Use, ui->phase7GV4Value, ui->phase7GV5_Label, ui->phase7GV5Use, ui->phase7GV5Value,ui->phase7REA_Label, ui->phase7RE1Use, ui->phase7RE1Value,ui->phase7REB_Label, ui->phase7RE2Use, ui->phase7RE2Value, true);
displayOnePhase(8, ui->phase8Name, ui->phase8Switch, ui->phase8FadeIn, ui->phase8FadeOut, ui->phase8Trim1Use, ui->phase8Trim1Value, ui->phase8Trim1Label, ui->phase8Trim1Slider, ui->phase8Trim2Use, ui->phase8Trim2Value, ui->phase8Trim2Label, ui->phase8Trim2Slider, ui->phase8Trim3Use, ui->phase8Trim3Value, ui->phase8Trim3Label, ui->phase8Trim3Slider, ui->phase8Trim4Use, ui->phase8Trim4Value, ui->phase8Trim4Label, ui->phase8Trim4Slider, ui->phase8GV1_Label, ui->phase8GV1Use, ui->phase8GV1Value, ui->phase8GV2_Label, ui->phase8GV2Use, ui->phase8GV2Value, ui->phase8GV3_Label, ui->phase8GV3Use, ui->phase8GV3Value, ui->phase8GV4_Label, ui->phase8GV4Use, ui->phase8GV4Value, ui->phase8GV5_Label, ui->phase8GV5Use, ui->phase8GV5Value,ui->phase8REA_Label, ui->phase8RE1Use, ui->phase8RE1Value,ui->phase8REB_Label, ui->phase8RE2Use, ui->phase8RE2Value, true);
QSlider * tmpsliders[9][4]={
{ui->phase0Trim1Slider,ui->phase0Trim2Slider,ui->phase0Trim3Slider,ui->phase0Trim4Slider},
{ui->phase1Trim1Slider,ui->phase1Trim2Slider,ui->phase1Trim3Slider,ui->phase1Trim4Slider},
{ui->phase2Trim1Slider,ui->phase2Trim2Slider,ui->phase2Trim3Slider,ui->phase2Trim4Slider},
{ui->phase3Trim1Slider,ui->phase3Trim2Slider,ui->phase3Trim3Slider,ui->phase3Trim4Slider},
{ui->phase4Trim1Slider,ui->phase4Trim2Slider,ui->phase4Trim3Slider,ui->phase4Trim4Slider},
{ui->phase5Trim1Slider,ui->phase5Trim2Slider,ui->phase5Trim3Slider,ui->phase5Trim4Slider},
{ui->phase6Trim1Slider,ui->phase6Trim2Slider,ui->phase6Trim3Slider,ui->phase6Trim4Slider},
{ui->phase7Trim1Slider,ui->phase7Trim2Slider,ui->phase7Trim3Slider,ui->phase7Trim4Slider},
{ui->phase8Trim1Slider,ui->phase8Trim2Slider,ui->phase8Trim3Slider,ui->phase8Trim4Slider}
};
QSpinBox * tmpspinbox[9][4]={
{ui->phase0Trim1Value,ui->phase0Trim2Value,ui->phase0Trim3Value,ui->phase0Trim4Value},
{ui->phase1Trim1Value,ui->phase1Trim2Value,ui->phase1Trim3Value,ui->phase1Trim4Value},
{ui->phase2Trim1Value,ui->phase2Trim2Value,ui->phase2Trim3Value,ui->phase2Trim4Value},
{ui->phase3Trim1Value,ui->phase3Trim2Value,ui->phase3Trim3Value,ui->phase3Trim4Value},
{ui->phase4Trim1Value,ui->phase4Trim2Value,ui->phase4Trim3Value,ui->phase4Trim4Value},
{ui->phase5Trim1Value,ui->phase5Trim2Value,ui->phase5Trim3Value,ui->phase5Trim4Value},
{ui->phase6Trim1Value,ui->phase6Trim2Value,ui->phase6Trim3Value,ui->phase6Trim4Value},
{ui->phase7Trim1Value,ui->phase7Trim2Value,ui->phase7Trim3Value,ui->phase7Trim4Value},
{ui->phase8Trim1Value,ui->phase8Trim2Value,ui->phase8Trim3Value,ui->phase8Trim4Value}
};
memcpy(phasesTrimSliders,tmpsliders,sizeof(phasesTrimSliders));
memcpy(phasesTrimValues,tmpspinbox,sizeof(phasesTrimValues));
int phases = GetEepromInterface()->getCapability(FlightPhases);
if (phases < 9) {
ui->phase8->setDisabled(true);
ui->phases->removeTab(8);
}
if (phases < 8) {
ui->phase7->setDisabled(true);
ui->phases->removeTab(7);
}
if (phases < 7) {
ui->phase6->setDisabled(true);
ui->phases->removeTab(6);
}
if (phases < 6) {
ui->phase5->setDisabled(true);
ui->phases->removeTab(5);
}
if (phases < 5) {
ui->phase4->setDisabled(true);
ui->phases->removeTab(4);
}
if (phases < 4) {
ui->phase3->setDisabled(true);
ui->phases->removeTab(3);
}
if (phases < 3) {
ui->phase2->setDisabled(true);
ui->phases->removeTab(2);
}
if (phases < 2) {
ui->phase1->setDisabled(true);
ui->phases->removeTab(1);
ui->phase0Name->setDisabled(true);
ui->phase0FadeIn->setDisabled(true);
ui->phase0FadeOut->setDisabled(true);
}
if ( GetEepromInterface()->getCapability(FlightPhasesAreNamed) ) {
for (int i=0; i < phases; i++) {
QString PhaseName=g_model.phaseData[i].name;
QString TabName;
if (i==0) {
TabName.append(QObject::tr("Flight Mode 0 (Default)"));
} else {
TabName.append(QObject::tr("FM %1").arg(i));
}
if (!PhaseName.isEmpty()) {
TabName.append(" (");
TabName.append(PhaseName);
TabName.append(")");
}
ui->phases->setTabText(i,TabName);
}
} else {
QLineEdit * tmp[]= { ui->phase0Name,ui->phase1Name,ui->phase2Name,ui->phase3Name,ui->phase4Name,ui->phase5Name,ui->phase6Name,ui->phase7Name,ui->phase8Name};
QLabel * tmp2[] = { ui->label_fm0name,ui->label_fm1name,ui->label_fm2name,ui->label_fm3name,ui->label_fm4name,ui->label_fm5name,ui->label_fm6name,ui->label_fm7name,ui->label_fm8name};
for (int i=0; i < phases; i++) {
tmp[i]->hide();
tmp2[i]->hide();
}
}
ui->phases->setCurrentIndex(0);
phasesLock = false;
}
void ModelEdit::on_phases_currentChanged(int index)
{
phasesLock = true;
switch(index) {
case 1:
displayOnePhase(1, NULL, NULL, NULL, NULL, NULL, ui->phase1Trim1Value, NULL, ui->phase1Trim1Slider, NULL, ui->phase1Trim2Value, NULL, ui->phase1Trim2Slider, NULL, ui->phase1Trim3Value, NULL, ui->phase1Trim3Slider, NULL, ui->phase1Trim4Value, NULL, ui->phase1Trim4Slider, NULL, NULL, ui->phase1GV1Value, NULL, NULL, ui->phase1GV2Value, NULL, NULL, ui->phase1GV3Value, NULL, NULL, ui->phase1GV4Value, NULL, NULL, ui->phase1GV5Value,NULL,NULL, ui->phase1RE1Value,NULL,NULL, ui->phase1RE2Value);
break;
case 2:
displayOnePhase(2, NULL, NULL, NULL, NULL, NULL, ui->phase2Trim1Value, NULL, ui->phase2Trim1Slider, NULL, ui->phase2Trim2Value, NULL, ui->phase2Trim2Slider, NULL, ui->phase2Trim3Value, NULL, ui->phase2Trim3Slider, NULL, ui->phase2Trim4Value, NULL, ui->phase2Trim4Slider, NULL, NULL, ui->phase2GV1Value, NULL, NULL, ui->phase2GV2Value, NULL, NULL, ui->phase2GV3Value, NULL, NULL, ui->phase2GV4Value, NULL, NULL, ui->phase2GV5Value,NULL,NULL, ui->phase2RE1Value,NULL,NULL, ui->phase2RE2Value);
break;
case 3:
displayOnePhase(3, NULL, NULL, NULL, NULL, NULL, ui->phase3Trim1Value, NULL, ui->phase3Trim1Slider, NULL, ui->phase3Trim2Value, NULL, ui->phase3Trim2Slider, NULL, ui->phase3Trim3Value, NULL, ui->phase3Trim3Slider, NULL, ui->phase3Trim4Value, NULL, ui->phase3Trim4Slider, NULL, NULL, ui->phase3GV1Value, NULL, NULL, ui->phase3GV2Value, NULL, NULL, ui->phase3GV3Value, NULL, NULL, ui->phase3GV4Value, NULL, NULL, ui->phase3GV5Value,NULL,NULL, ui->phase3RE1Value,NULL,NULL, ui->phase3RE2Value);
break;
case 4:
displayOnePhase(4, NULL, NULL, NULL, NULL, NULL, ui->phase4Trim1Value, NULL, ui->phase4Trim1Slider, NULL, ui->phase4Trim2Value, NULL, ui->phase4Trim2Slider, NULL, ui->phase4Trim3Value, NULL, ui->phase4Trim3Slider, NULL, ui->phase4Trim4Value, NULL, ui->phase4Trim4Slider, NULL, NULL, ui->phase4GV1Value, NULL, NULL, ui->phase4GV2Value, NULL, NULL, ui->phase4GV3Value, NULL, NULL, ui->phase4GV4Value, NULL, NULL, ui->phase4GV5Value,NULL,NULL, ui->phase4RE1Value,NULL,NULL, ui->phase4RE2Value);
break;
case 5:
displayOnePhase(5, NULL, NULL, NULL, NULL, NULL, ui->phase5Trim1Value, NULL, ui->phase5Trim1Slider, NULL, ui->phase5Trim2Value, NULL, ui->phase5Trim2Slider, NULL, ui->phase5Trim3Value, NULL, ui->phase5Trim3Slider, NULL, ui->phase5Trim4Value, NULL, ui->phase5Trim4Slider, NULL, NULL, ui->phase5GV1Value, NULL, NULL, ui->phase5GV2Value, NULL, NULL, ui->phase5GV3Value, NULL, NULL, ui->phase5GV4Value, NULL, NULL, ui->phase5GV5Value,NULL,NULL, ui->phase5RE1Value,NULL,NULL, ui->phase5RE2Value);
break;
case 6:
displayOnePhase(6, NULL, NULL, NULL, NULL, NULL, ui->phase6Trim1Value, NULL, ui->phase6Trim1Slider, NULL, ui->phase6Trim2Value, NULL, ui->phase6Trim2Slider, NULL, ui->phase6Trim3Value, NULL, ui->phase6Trim3Slider, NULL, ui->phase6Trim4Value, NULL, ui->phase6Trim4Slider, NULL, NULL, ui->phase6GV1Value, NULL, NULL, ui->phase6GV2Value, NULL, NULL, ui->phase6GV3Value, NULL, NULL, ui->phase6GV4Value, NULL, NULL, ui->phase6GV5Value,NULL,NULL, ui->phase6RE1Value,NULL,NULL, ui->phase6RE2Value);
break;
case 7:
displayOnePhase(7, NULL, NULL, NULL, NULL, NULL, ui->phase7Trim1Value, NULL, ui->phase7Trim1Slider, NULL, ui->phase7Trim2Value, NULL, ui->phase7Trim2Slider, NULL, ui->phase7Trim3Value, NULL, ui->phase7Trim3Slider, NULL, ui->phase7Trim4Value, NULL, ui->phase7Trim4Slider, NULL, NULL, ui->phase7GV1Value, NULL, NULL, ui->phase7GV2Value, NULL, NULL, ui->phase7GV3Value, NULL, NULL, ui->phase7GV4Value, NULL, NULL, ui->phase7GV5Value,NULL,NULL, ui->phase7RE1Value,NULL,NULL, ui->phase7RE2Value);
break;
case 8:
displayOnePhase(8, NULL, NULL, NULL, NULL, NULL, ui->phase8Trim1Value, NULL, ui->phase8Trim1Slider, NULL, ui->phase8Trim2Value, NULL, ui->phase8Trim2Slider, NULL, ui->phase8Trim3Value, NULL, ui->phase8Trim3Slider, NULL, ui->phase8Trim4Value, NULL, ui->phase8Trim4Slider, NULL, NULL, ui->phase8GV1Value, NULL, NULL, ui->phase8GV2Value, NULL, NULL, ui->phase8GV3Value, NULL, NULL, ui->phase8GV4Value, NULL, NULL, ui->phase8GV5Value,NULL,NULL, ui->phase8RE1Value,NULL,NULL, ui->phase8RE2Value);
break;
}
phasesLock = false;
}
void ModelEdit::tabExpos()
{
// curDest -> destination channel
// i -> mixer number
QByteArray qba;
ExposlistWidget->clear();
int curDest = -1;
for(int i=0; i<C9X_MAX_EXPOS; i++) {
ExpoData *md = &g_model.expoData[i];
if (md->mode==0) break;
QString str = "";
while(curDest<(int)md->chn-1) {
curDest++;
str = getStickStr(curDest);
qba.clear();
qba.append((quint8)-curDest-1);
QListWidgetItem *itm = new QListWidgetItem(str);
itm->setData(Qt::UserRole,qba);
ExposlistWidget->addItem(itm);
}
if(curDest!=(int)md->chn) {
str = getStickStr(md->chn);
curDest = md->chn;
} else {
str = " ";
}
switch (md->mode) {
case (1): str += " <-"; break;
case (2): str += " ->"; break;
default: str += " "; break;
};
str += tr("Weight") + getGVarString(md->weight).rightJustified(6, ' ');
if (!GetEepromInterface()->getCapability(ExpoIsCurve)) {
if (md->expo!=0)
str += " " + tr("Expo") + getGVarString(md->expo, true).rightJustified(7, ' ');
} else {
if (md->curveMode==0 && md->curveParam!=0)
str += " " + tr("Expo") + getGVarString(md->curveParam, true).rightJustified(7, ' ');
}
if (GetEepromInterface()->getCapability(FlightPhases)) {
if(md->phases) {
if (md->phases!=(unsigned int)(1<<GetEepromInterface()->getCapability(FlightPhases))-1) {
int mask=1;
int first=0;
for (int i=0; i<GetEepromInterface()->getCapability(FlightPhases);i++) {
if (!(md->phases & mask)) {
first++;
}
mask <<=1;
}
if (first>1) {
str += " " + tr("Flight modes") + QString("(");
} else {
str += " " + tr("Flight mode") + QString("(");
}
mask=1;
first=1;
for (int i=0; i<GetEepromInterface()->getCapability(FlightPhases);i++) {
if (!(md->phases & mask)) {
if (!first) {
str += QString(", ")+ QString("%1").arg(getPhaseName(i+1, g_model.phaseData[i].name));
} else {
str += QString("%1").arg(getPhaseName(i+1,g_model.phaseData[i].name));
first=0;
}
}
mask <<=1;
}
str += QString(")");
} else {
str += tr("DISABLED")+QString(" !!!");
}
}
}
if (md->swtch.type != SWITCH_TYPE_NONE) str += " " + tr("Switch") + QString("(%1)").arg(md->swtch.toString());
if (md->curveMode)
if (md->curveParam) str += " " + tr("Curve") + QString("(%1)").arg(getCurveStr(md->curveParam));
if (GetEepromInterface()->getCapability(HasExpoNames)) {
QString ExpoName;
ExpoName.append(md->name);
if (!ExpoName.isEmpty()) {
str+=QString("(%1)").arg(ExpoName);
}
}
qba.clear();
qba.append((quint8)i);
qba.append((const char*)md, sizeof(ExpoData));
QListWidgetItem *itm = new QListWidgetItem(str);
itm->setData(Qt::UserRole,qba); // expo number
ExposlistWidget->addItem(itm); //(str);
}
while(curDest<NUM_STICKS-1) {
curDest++;
QString str = getStickStr(curDest);
qba.clear();
qba.append((quint8)-curDest-1);
QListWidgetItem *itm = new QListWidgetItem(str);
itm->setData(Qt::UserRole,qba); // add new expo
ExposlistWidget->addItem(itm);
}
}
void ModelEdit::exposEdited()
{
updateSettings();
}
void ModelEdit::tabMixes()
{
// curDest -> destination channel4
// i -> mixer number
QByteArray qba;
MixerlistWidget->clear();
unsigned int curDest = 0;
int i;
unsigned int outputs = GetEepromInterface()->getCapability(Outputs);
int showNames=ui->showNames_Ckb->isChecked();
for(i=0; i<GetEepromInterface()->getCapability(Mixes); i++) {
MixData *md = &g_model.mixData[i];
if ((md->destCh==0) || (md->destCh>outputs+(unsigned int)GetEepromInterface()->getCapability(ExtraChannels))) continue;
QString str = "";
while(curDest<(md->destCh-1)) {
curDest++;
if (curDest > outputs) {
str = tr("X%1 ").arg(curDest-outputs);
} else {
str = tr("CH%1%2").arg(curDest/10).arg(curDest%10);
if (GetEepromInterface()->getCapability(HasChNames) && showNames) {
QString name=g_model.limitData[curDest-1].name;
if (!name.isEmpty()) {
name.append(" ");
str=name.left(6);
}
}
}
qba.clear();
qba.append((quint8)-curDest);
QListWidgetItem *itm = new QListWidgetItem(str);
itm->setData(Qt::UserRole,qba);
MixerlistWidget->addItem(itm);
}
if (md->destCh > outputs) {
str = tr("X%1 ").arg(md->destCh-outputs);
} else {
str = tr("CH%1%2").arg(md->destCh/10).arg(md->destCh%10);
str.append(" ");
if (GetEepromInterface()->getCapability(HasChNames) && showNames) {
QString name=g_model.limitData[md->destCh-1].name;
if (!name.isEmpty()) {
name.append(" ");
str=name.left(6);
}
}
}
if (curDest != md->destCh) {
curDest = md->destCh;
} else {
str.fill(' ');
}
switch(md->mltpx) {
case (1): str += " *"; break;
case (2): str += " R"; break;
default: str += " "; break;
};
str += " " + getGVarString(md->weight, true).rightJustified(6, ' ');
str += md->srcRaw.toString();
unsigned int fpCount = GetEepromInterface()->getCapability(FlightPhases);
if (GetEepromInterface()->getCapability(FlightPhases)) {
if(md->phases) {
if (md->phases!=(unsigned int)(1<<fpCount)-1) {
int mask=1;
int first=0;
for (unsigned int i=0; i<fpCount; i++) {
if (!(md->phases & mask)) {
first++;
}
mask <<=1;
}
if (first>1) {
str += " " + tr("Flight modes") + QString("(");
} else {
str += " " + tr("Flight mode") + QString("(");
}
mask=1;
first=1;
for (unsigned int i=0; i<fpCount; i++) {
if (!(md->phases & mask)) {
if (!first) {
str += QString(", ")+ QString("%1").arg(getPhaseName(i+1, g_model.phaseData[i].name));
}
else {
str += QString("%1").arg(getPhaseName(i+1,g_model.phaseData[i].name));
first=0;
}
}
mask <<=1;
}
str += QString(")");
} else {
str += tr("DISABLED")+QString(" !!!");
}
}
}
if(md->swtch.type != SWITCH_TYPE_NONE) str += " " + tr("Switch") + QString("(%1)").arg(md->swtch.toString());
if(md->carryTrim>0) {
str += " " +tr("No Trim");
} else if (md->carryTrim<0) {
str += " " + RawSource(SOURCE_TYPE_TRIM, (-(md->carryTrim)-1)).toString();
}
if(md->noExpo) {
str += " " +tr("No DR/Expo");
}
if (GetEepromInterface()->getCapability(MixFmTrim) && md->enableFmTrim==1) {
if (md->sOffset) str += " " + tr("FMTrim") + QString("(%1%)").arg(md->sOffset);
} else {
if (md->sOffset) str += " " + tr("Offset") + getGVarString(md->sOffset);
}
if (md->differential) str += " " + tr("Diff") + getGVarString(md->differential);
if (md->curve) str += " " + tr("Curve") + QString("(%1)").arg(getCurveStr(md->curve));
int scale=GetEepromInterface()->getCapability(SlowScale);
if (scale==0)
scale=1;
if (md->delayDown || md->delayUp)
str += tr(" Delay(u%1:d%2)").arg((double)md->delayUp/scale).arg((double)md->delayDown/scale);
if (md->speedDown || md->speedUp)
str += tr(" Slow(u%1:d%2)").arg((double)md->speedUp/scale).arg((double)md->speedDown/scale);
if (md->mixWarn) str += tr(" Warn(%1)").arg(md->mixWarn);
if (GetEepromInterface()->getCapability(HasMixerNames)) {
QString MixerName;
MixerName.append(md->name);
if (!MixerName.isEmpty()) {
str+=QString("(%1)").arg(MixerName);
}
}
qba.clear();
qba.append((quint8)i);
qba.append((const char*)md, sizeof(MixData));
QListWidgetItem *itm = new QListWidgetItem(str);
itm->setData(Qt::UserRole,qba); // mix number
MixerlistWidget->addItem(itm);//(str);
}
while(curDest<outputs+GetEepromInterface()->getCapability(ExtraChannels)) {
curDest++;
QString str;
if (curDest > outputs) {
str = tr("X%1 ").arg(curDest-outputs);
} else {
str = tr("CH%1%2").arg(curDest/10).arg(curDest%10);
if (GetEepromInterface()->getCapability(HasChNames) && showNames) {
QString name=g_model.limitData[curDest-1].name;
if (!name.isEmpty()) {
name.append(" ");
str=name.left(6);
}
}
}
qba.clear();
qba.append((quint8)-curDest);
QListWidgetItem *itm = new QListWidgetItem(str);
itm->setData(Qt::UserRole,qba); // add new mixer
MixerlistWidget->addItem(itm);
}
}
void ModelEdit::mixesEdited()
{
updateSettings();
}
void ModelEdit::tabHeli()
{
updateHeliTab();
connect(ui->swashTypeCB,SIGNAL(currentIndexChanged(int)),this,SLOT(heliEdited()));
connect(ui->swashCollectiveCB,SIGNAL(currentIndexChanged(int)),this,SLOT(heliEdited()));
connect(ui->swashRingValSB,SIGNAL(editingFinished()),this,SLOT(heliEdited()));
connect(ui->swashInvertELE,SIGNAL(stateChanged(int)),this,SLOT(heliEdited()));
connect(ui->swashInvertAIL,SIGNAL(stateChanged(int)),this,SLOT(heliEdited()));
connect(ui->swashInvertCOL,SIGNAL(stateChanged(int)),this,SLOT(heliEdited()));
}
void ModelEdit::updateHeliTab()
{
heliEditLock = true;
ui->swashTypeCB->setCurrentIndex(g_model.swashRingData.type);
populateSourceCB(ui->swashCollectiveCB, g_model.swashRingData.collectiveSource, POPULATE_SOURCES | POPULATE_SWITCHES | POPULATE_TRIMS);
ui->swashRingValSB->setValue(g_model.swashRingData.value);
ui->swashInvertELE->setChecked(g_model.swashRingData.invertELE);
ui->swashInvertAIL->setChecked(g_model.swashRingData.invertAIL);
ui->swashInvertCOL->setChecked(g_model.swashRingData.invertCOL);
heliEditLock = false;
}
void ModelEdit::heliEdited()
{
if(heliEditLock) return;
g_model.swashRingData.type = ui->swashTypeCB->currentIndex();
g_model.swashRingData.collectiveSource = ui->swashCollectiveCB->itemData(ui->swashCollectiveCB->currentIndex()).toInt();
g_model.swashRingData.value = ui->swashRingValSB->value();
g_model.swashRingData.invertELE = ui->swashInvertELE->isChecked();
g_model.swashRingData.invertAIL = ui->swashInvertAIL->isChecked();
g_model.swashRingData.invertCOL = ui->swashInvertCOL->isChecked();
updateSettings();
}
void ModelEdit::tabLimits()
{
limitEditLock=true;
int chnames=GetEepromInterface()->getCapability(HasChNames);
QRegExp rx(CHAR_FOR_NAMES_REGEX);
foreach(QLineEdit *le, findChildren<QLineEdit *>(QRegExp("CHName_[0-9]+"))) {
int len=le->objectName().mid(le->objectName().lastIndexOf("_")+1).toInt()-1;
if (chnames ) {
QString name=g_model.limitData[len].name;
if (name.trimmed().isEmpty()) {
le->setText(tr("CH %1").arg(len+1));
} else {
le->setText(name);
}
le->setValidator(new QRegExpValidator(rx, this));
le->setEnabled(true);
le->setReadOnly(false);
connect(le, SIGNAL(editingFinished()), this, SLOT(limitNameEdited()));
} else {
le->setText(tr("CH %1").arg(len+1));
le->setDisabled(true);
le->setReadOnly(true);
}
}
limitEditLock=false;
foreach(QDoubleSpinBox *sb, findChildren<QDoubleSpinBox *>(QRegExp("offsetDSB_[0-9]+"))) {
int sbn=sb->objectName().mid(sb->objectName().lastIndexOf("_")+1).toInt()-1;
sb->setValue(g_model.limitData[sbn].offset/10.0);
connect(sb, SIGNAL(editingFinished()), this, SLOT(limitOffsetEdited()));
}
foreach(QSpinBox *sb, findChildren<QSpinBox *>(QRegExp("minSB_[0-9]+"))) {
int sbn=sb->objectName().mid(sb->objectName().lastIndexOf("_")+1).toInt()-1;
sb->setValue(g_model.limitData[sbn].min);
connect(sb, SIGNAL(editingFinished()), this, SLOT(limitEdited()));
}
foreach(QSpinBox *sb, findChildren<QSpinBox *>(QRegExp("maxSB_[0-9]+"))) {
int sbn=sb->objectName().mid(sb->objectName().lastIndexOf("_")+1).toInt()-1;
sb->setValue(g_model.limitData[sbn].max);
connect(sb, SIGNAL(editingFinished()), this, SLOT(limitEdited()));
}
foreach(QComboBox *cb, findChildren<QComboBox *>(QRegExp("chInvCB_[0-9]+"))) {
int cbn=cb->objectName().mid(cb->objectName().lastIndexOf("_")+1).toInt()-1;
cb->setCurrentIndex((g_model.limitData[cbn].revert) ? 1 : 0);
connect(cb, SIGNAL(currentIndexChanged(int)), this, SLOT(limitInvEdited()));
}
if (GetEepromInterface()->getCapability(PPMCenter)) {
foreach(QSpinBox *sb, findChildren<QSpinBox *>(QRegExp("ppmcenter_[0-9]+"))) {
int sbn=sb->objectName().mid(sb->objectName().lastIndexOf("_")+1).toInt()-1;
sb->setValue(g_model.limitData[sbn].ppmCenter+1500);
connect(sb, SIGNAL(editingFinished()), this, SLOT(ppmcenterEdited()));
}
} else {
foreach(QSpinBox *sb, findChildren<QSpinBox *>(QRegExp("ppmcenter_[0-9]+"))) {
sb->hide();
}
ui->ppmc_label1->hide();
ui->ppmc_label2->hide();
}
if (GetEepromInterface()->getCapability(SYMLimits)) {
foreach(QCheckBox *ckb, findChildren<QCheckBox *>(QRegExp("symckb_[0-9]+"))) {
int ckbn=ckb->objectName().mid(ckb->objectName().lastIndexOf("_")+1).toInt()-1;
ckb->setChecked(g_model.limitData[ckbn].symetrical);
connect(ckb, SIGNAL(toggled(bool)), this, SLOT(limitSymEdited()));
}
} else {
foreach(QCheckBox *ckb, findChildren<QCheckBox *>(QRegExp("symckb_[0-9]+"))) {
ckb->hide();
}
ui->label_sym01->hide();
ui->label_sym02->hide();
}
if (GetEepromInterface()->getCapability(Outputs)<17) {
ui->limitGB2->hide();
}
setLimitMinMax();
}
void ModelEdit::updateCurvesTab()
{
ControlCurveSignal(true);
foreach(QCheckBox *ChkB, findChildren<QCheckBox *>(QRegExp("plotCB_[0-9]+"))) {
int ChkBn=ChkB->objectName().mid(ChkB->objectName().lastIndexOf("_")+1).toInt()-1;
ChkB->setChecked(plot_curve[ChkBn]);
}
ControlCurveSignal(false);
}
void ModelEdit::tabCurves()
{
QSpinBox* tmpy[17] = {
ui->curvePt01_y, ui->curvePt02_y, ui->curvePt03_y, ui->curvePt04_y, ui->curvePt05_y,
ui->curvePt06_y, ui->curvePt07_y, ui->curvePt08_y, ui->curvePt09_y, ui->curvePt10_y,
ui->curvePt11_y, ui->curvePt12_y, ui->curvePt13_y, ui->curvePt14_y, ui->curvePt15_y,
ui->curvePt16_y, ui->curvePt17_y };
QSpinBox* tmpx[17] = {
ui->curvePt01_x, ui->curvePt02_x, ui->curvePt03_x, ui->curvePt04_x, ui->curvePt05_x,
ui->curvePt06_x, ui->curvePt07_x, ui->curvePt08_x, ui->curvePt09_x, ui->curvePt10_x,
ui->curvePt11_x, ui->curvePt12_x, ui->curvePt13_x, ui->curvePt14_x, ui->curvePt15_x,
ui->curvePt16_x, ui->curvePt17_x };
QPushButton * editb[16]= {
ui->curveEdit_1,ui->curveEdit_2,ui->curveEdit_3,ui->curveEdit_4,
ui->curveEdit_5,ui->curveEdit_6,ui->curveEdit_7,ui->curveEdit_8,
ui->curveEdit_9,ui->curveEdit_10,ui->curveEdit_11,ui->curveEdit_12,
ui->curveEdit_13,ui->curveEdit_14,ui->curveEdit_15,ui->curveEdit_16 };
QPushButton * resetb[16]= {
ui->resetCurve_1,ui->resetCurve_2,ui->resetCurve_3,ui->resetCurve_4,
ui->resetCurve_5,ui->resetCurve_6,ui->resetCurve_7,ui->resetCurve_8,
ui->resetCurve_9,ui->resetCurve_10,ui->resetCurve_11,ui->resetCurve_12,
ui->resetCurve_13,ui->resetCurve_14,ui->resetCurve_15,ui->resetCurve_16 };
QCheckBox * plotcb[16]= {
ui->plotCB_1,ui->plotCB_2,ui->plotCB_3,ui->plotCB_4,
ui->plotCB_5,ui->plotCB_6,ui->plotCB_7,ui->plotCB_8,
ui->plotCB_9,ui->plotCB_10,ui->plotCB_11,ui->plotCB_12,
ui->plotCB_13,ui->plotCB_14,ui->plotCB_15,ui->plotCB_16 };
memcpy(spny, tmpy, sizeof(spny));
memcpy(spnx, tmpx, sizeof(spnx));
int numcurves=GetEepromInterface()->getCapability(NumCurves);
if (numcurves==0) {
numcurves=16;
}
if (!GetEepromInterface()->getCapability(CustomCurves)){
ui->curvetype_CB->setDisabled(true);
int count=0;
for (int i=0; i< GetEepromInterface()->getCapability(NumCurves3); i++) {
g_model.curves[count].count=3;
g_model.curves[count].custom=false;
count++;
}
for (int i=0; i< GetEepromInterface()->getCapability(NumCurves5); i++) {
g_model.curves[count].count=5;
g_model.curves[count].custom=false;
count++;
}
for (int i=0; i< GetEepromInterface()->getCapability(NumCurves9); i++) {
g_model.curves[count].count=9;
g_model.curves[count].custom=false;
count++;
}
for (int i=count; i< 16; i++) {
editb[i]->hide();
plotcb[i]->hide();
resetb[i]->hide();
}
} else {
ui->curvetype_CB->setEnabled(true);
}
if (!GetEepromInterface()->getCapability(HasCvNames)){
ui->cname_LE->hide();
ui->cname_label->hide();
} else {
ui->cname_LE->setText(g_model.curves[0].name);
}
for (int i=numcurves; i<16;i++) {
editb[i]->hide();
resetb[i]->hide();
plotcb[i]->hide();
}
for (int i=0; i<16;i++) {
plot_curve[i]=FALSE;
}
redrawCurve=true;
drawing=false;
#ifdef __APPLE__
ui->curveEdit_1->setStyleSheet("color: #00007f;");
ui->curveEdit_2->setStyleSheet("color: #007f00;");
ui->curveEdit_3->setStyleSheet("color: #7f0000;");
ui->curveEdit_4->setStyleSheet("color: #007f7f;");
ui->curveEdit_5->setStyleSheet("color: #7f007f;");
ui->curveEdit_6->setStyleSheet("color: #7f7f00;");
ui->curveEdit_7->setStyleSheet("color: #7f7f7f;");
ui->curveEdit_8->setStyleSheet("color: #0000ff;");
ui->curveEdit_9->setStyleSheet("color: #007fff;");
ui->curveEdit_10->setStyleSheet("color: #7f00ff;");
ui->curveEdit_11->setStyleSheet("color: #00ff00;");
ui->curveEdit_12->setStyleSheet("color: #00ff7f;");
ui->curveEdit_13->setStyleSheet("color: #7fff00;");
ui->curveEdit_14->setStyleSheet("color: #ff0000;");
ui->curveEdit_15->setStyleSheet("color: #ff007f;");
ui->curveEdit_16->setStyleSheet("color: #ff7f00;");
#else
ui->curveEdit_1->setStyleSheet("background-color: #00007f; color: white;");
ui->curveEdit_2->setStyleSheet("background-color: #007f00; color: white;");
ui->curveEdit_3->setStyleSheet("background-color: #7f0000; color: white;");
ui->curveEdit_4->setStyleSheet("background-color: #007f7f; color: white;");
ui->curveEdit_5->setStyleSheet("background-color: #7f007f; color: white;");
ui->curveEdit_6->setStyleSheet("background-color: #7f7f00; color: white;");
ui->curveEdit_7->setStyleSheet("background-color: #7f7f7f; color: white;");
ui->curveEdit_8->setStyleSheet("background-color: #0000ff; color: white;");
ui->curveEdit_9->setStyleSheet("background-color: #007fff; color: white;");
ui->curveEdit_10->setStyleSheet("background-color: #7f00ff; color: white;");
ui->curveEdit_11->setStyleSheet("background-color: #00ff00; color: white;");
ui->curveEdit_12->setStyleSheet("background-color: #00ff7f; color: white;");
ui->curveEdit_13->setStyleSheet("background-color: #7fff00; color: white;");
ui->curveEdit_14->setStyleSheet("background-color: #ff0000; color: white;");
ui->curveEdit_15->setStyleSheet("background-color: #ff007f; color: white;");
ui->curveEdit_16->setStyleSheet("background-color: #ff7f00; color: white;");
#endif
updateCurvesTab();
QGraphicsScene *scene = new QGraphicsScene(ui->curvePreview);
scene->setItemIndexMethod(QGraphicsScene::NoIndex);
ui->curvePreview->setScene(scene);
currentCurve = 0;
connect(ui->clearMixesPB,SIGNAL(pressed()),this,SLOT(clearCurves()));
foreach(QSpinBox *sb, findChildren<QSpinBox *>(QRegExp("curvePt[0-9]+"))) {
connect(sb, SIGNAL(valueChanged(int)), this, SLOT(curvePointEdited()));
}
foreach(QPushButton *pb, findChildren<QPushButton *>(QRegExp("resetCurve_[0-9]+"))) {
connect(pb, SIGNAL(clicked()), this, SLOT(resetCurve()));
}
foreach(QPushButton *pb, findChildren<QPushButton *>(QRegExp("curveEdit_[0-9]+"))) {
connect(pb, SIGNAL(clicked()), this, SLOT(editCurve()));
}
foreach(QCheckBox *ChkB, findChildren<QCheckBox *>(QRegExp("plotCB_[0-9]+"))) {
connect(ChkB, SIGNAL(toggled(bool)), this, SLOT(plotCurve(bool)));
}
setCurrentCurve(currentCurve);
ui->ca_coeff_SB->hide();
ui->ca_coeff_label->hide();
ui->ca_ymid_SB->hide();
ui->ca_ymid_label->hide();
}
void ModelEdit::on_ca_ctype_CB_currentIndexChanged()
{
int index=ui->ca_ctype_CB->currentIndex();
switch (index) {
case 0:
ui->ca_coeff_SB->hide();
ui->ca_coeff_label->hide();
ui->ca_ymid_SB->hide();
ui->ca_ymid_label->hide();
ui->ca_ymin_SB->show();
ui->ca_ymin_label->show();
ui->ca_ymin_SB->setValue(-100);
ui->ca_ymax_SB->setValue(100);
break;
case 1:
ui->ca_coeff_SB->show();
ui->ca_coeff_label->show();
ui->ca_ymid_SB->hide();
ui->ca_ymid_label->hide();
ui->ca_ymin_SB->show();
ui->ca_ymin_label->show();
ui->ca_ymin_SB->setValue(-100);
ui->ca_ymax_SB->setValue(100);
break;
case 2:
ui->ca_coeff_SB->show();
ui->ca_coeff_label->show();
ui->ca_ymid_SB->hide();
ui->ca_ymid_label->hide();
ui->ca_ymin_SB->hide();
ui->ca_ymin_label->hide();
ui->ca_ymax_SB->setValue(100);
break;
case 3:
ui->ca_coeff_SB->show();
ui->ca_coeff_label->show();
ui->ca_ymid_SB->show();
ui->ca_ymid_label->show();
ui->ca_ymin_SB->hide();
ui->ca_ymin_label->hide();
ui->ca_ymid_SB->setValue(0);
ui->ca_ymax_SB->setValue(100);
break;
}
}
void ModelEdit::on_ca_apply_PB_clicked()
{
int index=ui->ca_ctype_CB->currentIndex();
float x;
int y;
int invert=0;
float a;
if (index==0) {
a=(ui->ca_ymax_SB->value()-ui->ca_ymin_SB->value())/200.0;
int numpoints=g_model.curves[currentCurve].count;
for (int i=0; i<numpoints; i++) {
if (g_model.curves[currentCurve].custom) {
x=(g_model.curves[currentCurve].points[i].x+100);
} else {
x=(200.0/(numpoints-1))*i;
}
y=ui->ca_ymin_SB->value()+a*x;
switch (ui->ca_side_CB->currentIndex()) {
case 0:
g_model.curves[currentCurve].points[i].y=y;
break;
case 1:
if (x>=100) {
g_model.curves[currentCurve].points[i].y=y;
}
break;
case 2:
if (x<100) {
g_model.curves[currentCurve].points[i].y=y;
}
break;
}
}
} else if (index==1) {
int numpoints=g_model.curves[currentCurve].count;
for (int i=0; i<numpoints; i++) {
if (g_model.curves[currentCurve].custom) {
x=((g_model.curves[currentCurve].points[i].x)+100)/2.0;
} else {
x=(100.0/(numpoints-1))*i;
}
a=ui->ca_coeff_SB->value();
if (a>=0) {
y=round(c9xexpou(x,a)*(ui->ca_ymax_SB->value()-ui->ca_ymin_SB->value())/100.0+ui->ca_ymin_SB->value());
} else {
a=-a;
x=100-x;
y=round((100.0-c9xexpou(x,a))*(ui->ca_ymax_SB->value()-ui->ca_ymin_SB->value())/100.0+ui->ca_ymin_SB->value());
}
switch (ui->ca_side_CB->currentIndex()) {
case 0:
g_model.curves[currentCurve].points[i].y=y;
break;
case 1:
if (x>=50) {
g_model.curves[currentCurve].points[i].y=y;
}
break;
case 2:
if (x<50) {
g_model.curves[currentCurve].points[i].y=y;
}
break;
}
}
} else if (index==2) {
int numpoints=g_model.curves[currentCurve].count;
for (int i=0; i<numpoints; i++) {
if (g_model.curves[currentCurve].custom) {
x=(g_model.curves[currentCurve].points[i].x);
} else {
x=-100.0+(200.0/(numpoints-1))*i;
}
a=ui->ca_coeff_SB->value();
if (x<0) {
x=-x;
invert=1;
} else {
invert=0;
}
if (a>=0) {
y=round(c9xexpou(x,a)*(ui->ca_ymax_SB->value()/100.0));
} else {
a=-a;
x=100-x;
y=round((100.0-c9xexpou(x,a))*(ui->ca_ymax_SB->value()/100.0));
}
switch (ui->ca_side_CB->currentIndex()) {
case 0:
if (invert==1) {
g_model.curves[currentCurve].points[i].y=-y;
} else {
g_model.curves[currentCurve].points[i].y=y;
}
break;
case 1:
if (invert==0) {
g_model.curves[currentCurve].points[i].y=y;
}
break;
case 2:
if (invert==1) {
g_model.curves[currentCurve].points[i].y=-y;
}
break;
}
}
} else if (index==3) {
int numpoints=g_model.curves[currentCurve].count;
for (int i=0; i<numpoints; i++) {
if (g_model.curves[currentCurve].custom) {
x=(g_model.curves[currentCurve].points[i].x);
} else {
x=-100.0+(200.0/(numpoints-1))*i;
}
int pos=(x>=0);
a=ui->ca_coeff_SB->value();
if (x<0) {
x=-x;
}
if (a>=0) {
y=round(c9xexpou(x,a)*((ui->ca_ymax_SB->value()-ui->ca_ymid_SB->value())/100.0)+ui->ca_ymid_SB->value());
} else {
a=-a;
x=100-x;
y=round((100.0-c9xexpou(x,a))*((ui->ca_ymax_SB->value()-ui->ca_ymid_SB->value())/100.0)+ui->ca_ymid_SB->value());
}
switch (ui->ca_side_CB->currentIndex()) {
case 0:
g_model.curves[currentCurve].points[i].y=y;
break;
case 1:
if (pos) {
g_model.curves[currentCurve].points[i].y=y;
}
break;
case 2:
if (!pos) {
g_model.curves[currentCurve].points[i].y=y;
}
break;
}
}
}
updateSettings();
setCurrentCurve(currentCurve);
drawCurve();
}
void ModelEdit::limitSymEdited()
{
QCheckBox *ckb = qobject_cast<QCheckBox*>(sender());
int limitId=ckb->objectName().mid(ckb->objectName().lastIndexOf("_")+1).toInt()-1;
g_model.limitData[limitId].symetrical = (ckb->checkState() ? 1 : 0);
updateSettings();
}
void ModelEdit::limitNameEdited()
{
if(limitEditLock) return;
limitEditLock=true;
QLineEdit *le = qobject_cast<QLineEdit*>(sender());
int limitId=le->objectName().mid(le->objectName().lastIndexOf("_")+1).toInt()-1;
int i=0;
if (le->text()==tr("CH %1").arg(limitId+1)) {
le->setText("");
}
for (i=0; i<le->text().toAscii().length(); i++) {
g_model.limitData[limitId].name[i]=le->text().toAscii().at(i);
}
if (le->text().trimmed().isEmpty()) {
le->setText(tr("CH %1").arg(limitId+1));
}
g_model.limitData[limitId].name[i]=0;
updateSettings();
tabMixes();
limitEditLock=false;
}
void ModelEdit::limitOffsetEdited()
{
QDoubleSpinBox *dsb = qobject_cast<QDoubleSpinBox*>(sender());
int limitId=dsb->objectName().mid(dsb->objectName().lastIndexOf("_")+1).toInt()-1;
g_model.limitData[limitId].offset = round(dsb->value()*10);
updateSettings();
}
void ModelEdit::limitEdited()
{
QSpinBox *sb = qobject_cast<QSpinBox*>(sender());
int limitId=sb->objectName().mid(sb->objectName().lastIndexOf("_")+1).toInt()-1;
if (sb->objectName().indexOf("max")!=-1) {
g_model.limitData[limitId].max = sb->value();
}
else {
g_model.limitData[limitId].min = sb->value();
}
updateSettings();
}
void ModelEdit::limitInvEdited()
{
QComboBox *cb = qobject_cast<QComboBox*>(sender());
int limitId=cb->objectName().mid(cb->objectName().lastIndexOf("_")+1).toInt()-1;
g_model.limitData[limitId].revert = cb->currentIndex();
updateSettings();
}
void ModelEdit::ppmcenterEdited()
{
QSpinBox *sb = qobject_cast<QSpinBox*>(sender());
int limitId=sb->objectName().mid(sb->objectName().lastIndexOf("_")+1).toInt()-1;
g_model.limitData[limitId].ppmCenter = sb->value()-1500;
updateSettings();
}
void ModelEdit::startupSwitchEdited()
{
if (GetEepromInterface()->getCapability(Pots)==3) {
uint8_t i= 0;
i|=(uint8_t)ui->swwarn0_CB->currentIndex();
if (i==1) {
ui->swwarn1_ChkB->setDisabled(true) ;
ui->swwarn2_ChkB->setDisabled(true) ;
ui->swwarn3_ChkB->setDisabled(true) ;
ui->swwarn4_CB->setDisabled(true) ;
ui->swwarn5_ChkB->setDisabled(true) ;
ui->swwarn6_ChkB->setDisabled(true) ;
} else {
ui->swwarn1_ChkB->setEnabled(true) ;
ui->swwarn2_ChkB->setEnabled(true) ;
ui->swwarn3_ChkB->setEnabled(true) ;
ui->swwarn4_CB->setEnabled(true) ;
ui->swwarn5_ChkB->setEnabled(true) ;
ui->swwarn6_ChkB->setEnabled(true) ;
i|=(ui->swwarn1_ChkB->isChecked() ? 1 : 0)<<1;
i|=(ui->swwarn2_ChkB->isChecked() ? 1 : 0)<<2;
i|=(ui->swwarn3_ChkB->isChecked() ? 1 : 0)<<3;
i|=((uint8_t)ui->swwarn4_CB->currentIndex() & 0x03)<<4;
i|=(ui->swwarn5_ChkB->isChecked() ? 1 : 0)<<6;
i|=(ui->swwarn6_ChkB->isChecked() ? 1 : 0)<<7;
}
g_model.switchWarningStates=i;
} else {
uint16_t i= 0;
i|=(uint16_t)ui->tswwarn0_CB->currentIndex();
if (i==1) {
ui->chkSA->setDisabled(true);
ui->chkSB->setDisabled(true);
ui->chkSC->setDisabled(true);
ui->chkSD->setDisabled(true);
ui->chkSE->setDisabled(true);
ui->chkSF->setDisabled(true);
ui->chkSG->setDisabled(true);
} else {
ui->chkSA->setEnabled(true);
ui->chkSB->setEnabled(true);
ui->chkSC->setEnabled(true);
ui->chkSD->setEnabled(true);
ui->chkSE->setEnabled(true);
ui->chkSF->setEnabled(true);
ui->chkSG->setEnabled(true);
i|=(((uint16_t)ui->chkSA->value())<<1);
i|=(((uint16_t)ui->chkSB->value())<<3);
i|=(((uint16_t)ui->chkSC->value())<<5);
i|=(((uint16_t)ui->chkSD->value())<<7);
i|=(((uint16_t)ui->chkSE->value())<<9);
i|=(((uint16_t)ui->chkSF->value())<<12);
i|=(((uint16_t)ui->chkSG->value())<<13);
}
g_model.switchWarningStates=i;
}
updateSettings();
}
void ModelEdit::setCurrentCurve(int curveId)
{
currentCurve = curveId;
curvesLock=true;
QString ss = "QSpinBox { background-color:rgb(255, 255, 127);}";
for (int i=0; i<g_model.curves[currentCurve].count;i++) {
spny[i]->show();
spny[i]->setValue(g_model.curves[currentCurve].points[i].y);
if (!g_model.curves[currentCurve].custom || i==0 || i==(g_model.curves[currentCurve].count-1)) {
spnx[i]->hide();
if (i==0) {
spnx[i]->setValue(-100);
}
if (i==(g_model.curves[currentCurve].count-1)) {
spnx[i]->setValue(100);
}
} else {
spnx[i]->show();
spnx[i]->setMaximum(g_model.curves[currentCurve].points[i+1].x-1);
spnx[i]->setMinimum(g_model.curves[currentCurve].points[i-1].x+1);
spnx[i]->setValue(g_model.curves[currentCurve].points[i].x);
}
}
for (int i=g_model.curves[currentCurve].count; i<17;i++) {
spny[i]->hide();
spnx[i]->hide();
}
int index=0;
if (g_model.curves[currentCurve].count==3) {
index=0;
} else if (g_model.curves[currentCurve].count==5) {
index=2;
} else if (g_model.curves[currentCurve].count==9) {
index=4;
} else if (g_model.curves[currentCurve].count==17) {
index=6;
}
if (g_model.curves[currentCurve].custom) {
index++;
}
if (!GetEepromInterface()->getCapability(HasCvNames)){
ui->cname_LE->hide();
ui->cname_label->hide();
} else {
ui->cname_LE->setText(g_model.curves[currentCurve].name);
}
ui->curvetype_CB->setCurrentIndex(index);
curvesLock=false;
}
void ModelEdit::curvePointEdited()
{
if (curvesLock) {
return;
}
/* for (int i=1; i< g_model.curves[currentCurve].count-1; i++) {
if (g_model.curves[currentCurve].points[i].x>(100-g_model.curves[currentCurve].count+i)) {
g_model.curves[currentCurve].points[i].x=(100-g_model.curves[currentCurve].count+i);
}
if (g_model.curves[currentCurve].points[i].x<=g_model.curves[currentCurve].points[i-1].x) {
spnx[i]->setValue(spnx[i-1]->value()+1);
}
}
*/
for (int i=0; i< 17; i++) {
g_model.curves[currentCurve].points[i].x=spnx[i]->value();
g_model.curves[currentCurve].points[i].y=spny[i]->value();
}
if (redrawCurve)
drawCurve();
updateSettings();
}
void ModelEdit::setSwitchWidgetVisibility(int i)
{
RawSource source=RawSource(g_model.customSw[i].val1);
switch (getCSFunctionFamily(g_model.customSw[i].func))
{
case CS_FAMILY_VOFS:
cswitchSource1[i]->setVisible(true);
cswitchSource2[i]->setVisible(false);
cswitchValue[i]->setVisible(false);
cswitchOffset[i]->setVisible(true);
populateSourceCB(cswitchSource1[i], source, POPULATE_SOURCES | (GetEepromInterface()->getCapability(ExtraTrims) ? POPULATE_TRIMS : 0) | POPULATE_SWITCHES | POPULATE_TELEMETRY | (GetEepromInterface()->getCapability(GvarsInCS) ? POPULATE_GVARS : 0));
cswitchOffset[i]->setDecimals(source.getDecimals(g_model));
cswitchOffset[i]->setSingleStep(source.getStep(g_model));
if (g_model.customSw[i].func>CS_FN_ELESS && g_model.customSw[i].func<CS_FN_VEQUAL) {
cswitchOffset[i]->setMinimum(source.getStep(g_model)*-127);
cswitchOffset[i]->setMaximum(source.getStep(g_model)*127);
cswitchOffset[i]->setValue(source.getStep(g_model)*g_model.customSw[i].val2);
} else {
cswitchOffset[i]->setMinimum(source.getMin(g_model));
cswitchOffset[i]->setMaximum(source.getMax(g_model));
cswitchOffset[i]->setValue(source.getStep(g_model)*(g_model.customSw[i].val2+source.getRawOffset(g_model))+source.getOffset(g_model));
}
break;
case CS_FAMILY_VBOOL:
cswitchSource1[i]->setVisible(true);
cswitchSource2[i]->setVisible(true);
cswitchValue[i]->setVisible(false);
cswitchOffset[i]->setVisible(false);
populateSwitchCB(cswitchSource1[i], RawSwitch(g_model.customSw[i].val1));
populateSwitchCB(cswitchSource2[i], RawSwitch(g_model.customSw[i].val2));
break;
case CS_FAMILY_VCOMP:
cswitchSource1[i]->setVisible(true);
cswitchSource2[i]->setVisible(true);
cswitchValue[i]->setVisible(false);
cswitchOffset[i]->setVisible(false);
populateSourceCB(cswitchSource1[i], RawSource(g_model.customSw[i].val1), POPULATE_SOURCES | (GetEepromInterface()->getCapability(ExtraTrims) ? POPULATE_TRIMS : 0) | POPULATE_SWITCHES | POPULATE_TELEMETRY | (GetEepromInterface()->getCapability(GvarsInCS) ? POPULATE_GVARS : 0));
populateSourceCB(cswitchSource2[i], RawSource(g_model.customSw[i].val2), POPULATE_SOURCES | (GetEepromInterface()->getCapability(ExtraTrims) ? POPULATE_TRIMS : 0) | POPULATE_SWITCHES | POPULATE_TELEMETRY | (GetEepromInterface()->getCapability(GvarsInCS) ? POPULATE_GVARS : 0));
break;
case CS_FAMILY_TIMERS:
cswitchSource1[i]->setVisible(false);
cswitchSource2[i]->setVisible(false);
cswitchValue[i]->setVisible(true);
cswitchOffset[i]->setVisible(true);
cswitchOffset[i]->setDecimals(1);
cswitchOffset[i]->setMinimum(0.1);
cswitchOffset[i]->setMaximum(175);
float value=ValToTim(g_model.customSw[i].val2);
cswitchOffset[i]->setSingleStep(0.1);
if (value>60) {
cswitchOffset[i]->setSingleStep(1);
} else if (value>2) {
cswitchOffset[i]->setSingleStep(0.5);
}
cswitchOffset[i]->setValue(value);
cswitchValue[i]->setDecimals(1);
cswitchValue[i]->setMinimum(0.1);
cswitchValue[i]->setMaximum(175);
value=ValToTim(g_model.customSw[i].val1);
cswitchValue[i]->setSingleStep(0.1);
if (value>60) {
cswitchValue[i]->setSingleStep(1);
} else if (value>2) {
cswitchValue[i]->setSingleStep(0.5);
}
cswitchValue[i]->setValue(value);
break;
}
cswitchAnd[i]->setVisible(true);
populateSwitchCB(cswitchAnd[i], RawSwitch(g_model.customSw[i].andsw), POPULATE_AND_SWITCHES);
if (GetEepromInterface()->getCapability(CustomSwitchesExt)) {
cswitchDuration[i]->setVisible(true);
cswitchDuration[i]->setValue(g_model.customSw[i].duration/2.0);
cswitchDelay[i]->setVisible(true);
cswitchDelay[i]->setValue(g_model.customSw[i].delay/2.0);
}
}
void ModelEdit::updateSwitchesTab()
{
switchEditLock = true;
int num_csw=GetEepromInterface()->getCapability(CustomSwitches);
for (int i=0; i< num_csw; i++) {
populateCSWCB(csw[i], g_model.customSw[i].func);
setSwitchWidgetVisibility(i);
}
switchEditLock = false;
}
void ModelEdit::tabCustomSwitches()
{
switchEditLock = true;
QComboBox* tmpcsw[C9X_NUM_CSW] = {ui->cswitchFunc_1, ui->cswitchFunc_2, ui->cswitchFunc_3, ui->cswitchFunc_4,
ui->cswitchFunc_5, ui->cswitchFunc_6, ui->cswitchFunc_7, ui->cswitchFunc_8,
ui->cswitchFunc_9, ui->cswitchFunc_10, ui->cswitchFunc_11, ui->cswitchFunc_12,
ui->cswitchFunc_13, ui->cswitchFunc_14, ui->cswitchFunc_15, ui->cswitchFunc_16,
ui->cswitchFunc_17, ui->cswitchFunc_18, ui->cswitchFunc_19, ui->cswitchFunc_20,
ui->cswitchFunc_21, ui->cswitchFunc_22, ui->cswitchFunc_23, ui->cswitchFunc_24,
ui->cswitchFunc_25, ui->cswitchFunc_26, ui->cswitchFunc_27, ui->cswitchFunc_28,
ui->cswitchFunc_29, ui->cswitchFunc_30, ui->cswitchFunc_31, ui->cswitchFunc_32 };
QLabel* cswlabel[C9X_NUM_CSW] = { ui->cswlabel_01, ui->cswlabel_02, ui->cswlabel_03, ui->cswlabel_04,
ui->cswlabel_05, ui->cswlabel_06, ui->cswlabel_07, ui->cswlabel_08,
ui->cswlabel_09, ui->cswlabel_10, ui->cswlabel_11, ui->cswlabel_12,
ui->cswlabel_13, ui->cswlabel_14, ui->cswlabel_15, ui->cswlabel_16,
ui->cswlabel_17, ui->cswlabel_18, ui->cswlabel_19, ui->cswlabel_20,
ui->cswlabel_21, ui->cswlabel_22, ui->cswlabel_23, ui->cswlabel_24,
ui->cswlabel_25, ui->cswlabel_26, ui->cswlabel_27, ui->cswlabel_28,
ui->cswlabel_29, ui->cswlabel_30, ui->cswlabel_31, ui->cswlabel_32};
memcpy(csw, tmpcsw, sizeof(csw));
int num_csw=GetEepromInterface()->getCapability(CustomSwitches);
for(int i=0; i<16; i++) {
if (i<num_csw) {
tmpcsw[i]->setProperty("index",i);
cswitchSource1[i] = new QComboBox(this);
cswitchSource1[i]->setProperty("index",i);
connect(cswitchSource1[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customSwitchesEdited()));
ui->gridLayout_21->addWidget(cswitchSource1[i],i+1,2);
cswitchSource1[i]->setVisible(false);
cswitchValue[i] = new QDoubleSpinBox(this);
cswitchValue[i]->setMaximum(125);
cswitchValue[i]->setMinimum(-125);
cswitchValue[i]->setAccelerated(true);
cswitchValue[i]->setDecimals(0);
cswitchValue[i]->setProperty("index",i);
connect(cswitchValue[i],SIGNAL(editingFinished()),this,SLOT(customSwitchesEdited()));
ui->gridLayout_21->addWidget(cswitchValue[i],i+1,2);
cswitchValue[i]->setVisible(false);
cswitchSource2[i] = new QComboBox(this);
cswitchSource2[i]->setProperty("index",i);
connect(cswitchSource2[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customSwitchesEdited()));
ui->gridLayout_21->addWidget(cswitchSource2[i],i+1,3);
cswitchSource2[i]->setVisible(false);
cswitchOffset[i] = new QDoubleSpinBox(this);
cswitchOffset[i]->setProperty("index",i);
cswitchOffset[i]->setMaximum(125);
cswitchOffset[i]->setMinimum(-125);
cswitchOffset[i]->setAccelerated(true);
cswitchOffset[i]->setDecimals(0);
connect(cswitchOffset[i],SIGNAL(editingFinished()),this,SLOT(customSwitchesEdited()));
ui->gridLayout_21->addWidget(cswitchOffset[i],i+1,3);
cswitchOffset[i]->setVisible(false);
cswitchAnd[i] = new QComboBox(this);
cswitchAnd[i]->setProperty("index",i);
connect(cswitchAnd[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customSwitchesEdited()));
ui->gridLayout_21->addWidget(cswitchAnd[i],i+1,4);
cswitchAnd[i]->setVisible(false);
if (GetEepromInterface()->getCapability(CustomSwitchesExt)) {
cswitchDuration[i] = new QDoubleSpinBox(this);
cswitchDuration[i]->setProperty("index",i);
cswitchDuration[i]->setSingleStep(0.5);
cswitchDuration[i]->setMaximum(50);
cswitchDuration[i]->setMinimum(0);
cswitchDuration[i]->setAccelerated(true);
cswitchDuration[i]->setDecimals(1);
connect(cswitchDuration[i],SIGNAL(editingFinished()),this,SLOT(customSwitchesEdited()));
ui->gridLayout_21->addWidget(cswitchDuration[i],i+1,5);
cswitchDuration[i]->setVisible(false);
cswitchDelay[i] = new QDoubleSpinBox(this);
cswitchDelay[i]->setProperty("index",i);
cswitchDelay[i]->setSingleStep(0.5);
cswitchDelay[i]->setMaximum(50);
cswitchDelay[i]->setMinimum(0);
cswitchDelay[i]->setAccelerated(true);
cswitchDelay[i]->setDecimals(1);
connect(cswitchDelay[i],SIGNAL(editingFinished()),this,SLOT(customSwitchesEdited()));
ui->gridLayout_21->addWidget(cswitchDelay[i],i+1,6);
cswitchDelay[i]->setVisible(false);
} else {
ui->cswCol3->hide();
ui->cswCol4->hide();
}
connect(cswlabel[i],SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(csw_customContextMenuRequested(QPoint)));
} else {
csw[i]->hide();
cswlabel[i]->hide();
}
}
if (num_csw>16) {
for(int i=16; i<32; i++) {
if (i<=num_csw) {
tmpcsw[i]->setProperty("index",i);
cswitchSource1[i] = new QComboBox(this);
cswitchSource1[i]->setProperty("index",i);
connect(cswitchSource1[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customSwitchesEdited()));
ui->gridLayout_22->addWidget(cswitchSource1[i],i-15,2);
cswitchSource1[i]->setVisible(false);
cswitchValue[i] = new QDoubleSpinBox(this);
cswitchValue[i]->setProperty("index",i);
cswitchValue[i]->setMaximum(125);
cswitchValue[i]->setMinimum(-125);
cswitchValue[i]->setAccelerated(true);
cswitchValue[i]->setDecimals(0);
connect(cswitchValue[i],SIGNAL(editingFinished()),this,SLOT(customSwitchesEdited()));
ui->gridLayout_22->addWidget(cswitchValue[i],i-15,2);
cswitchValue[i]->setVisible(false);
cswitchSource2[i] = new QComboBox(this);
cswitchSource2[i]->setProperty("index",i);
connect(cswitchSource2[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customSwitchesEdited()));
ui->gridLayout_22->addWidget(cswitchSource2[i],i-15,3);
cswitchSource2[i]->setVisible(false);
cswitchOffset[i] = new QDoubleSpinBox(this);
cswitchOffset[i]->setProperty("index",i);
cswitchOffset[i]->setMaximum(125);
cswitchOffset[i]->setMinimum(-125);
cswitchOffset[i]->setAccelerated(true);
cswitchOffset[i]->setDecimals(0);
connect(cswitchOffset[i],SIGNAL(editingFinished()),this,SLOT(customSwitchesEdited()));
ui->gridLayout_22->addWidget(cswitchOffset[i],i-15,3);
cswitchOffset[i]->setVisible(false);
cswitchAnd[i] = new QComboBox(this);
cswitchAnd[i]->setProperty("index",i);
connect(cswitchAnd[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customSwitchesEdited()));
ui->gridLayout_22->addWidget(cswitchAnd[i],i-15,4);
cswitchAnd[i]->setVisible(false);
if (GetEepromInterface()->getCapability(CustomSwitchesExt)) {
cswitchDuration[i] = new QDoubleSpinBox(this);
cswitchDuration[i]->setProperty("index",i);
cswitchDuration[i]->setSingleStep(0.5);
cswitchDuration[i]->setMaximum(50);
cswitchDuration[i]->setMinimum(0);
cswitchDuration[i]->setAccelerated(true);
cswitchDuration[i]->setDecimals(1);
connect(cswitchDuration[i],SIGNAL(editingFinished()),this,SLOT(customSwitchesEdited()));
ui->gridLayout_22->addWidget(cswitchDuration[i],i-15,5);
cswitchDuration[i]->setVisible(false);
cswitchDelay[i] = new QDoubleSpinBox(this);
cswitchDelay[i]->setProperty("index",i);
cswitchDelay[i]->setSingleStep(0.5);
cswitchDelay[i]->setMaximum(50);
cswitchDelay[i]->setMinimum(0);
cswitchDelay[i]->setAccelerated(true);
cswitchDelay[i]->setDecimals(1);
connect(cswitchDelay[i],SIGNAL(editingFinished()),this,SLOT(customSwitchesEdited()));
ui->gridLayout_22->addWidget(cswitchDelay[i],i-15,6);
cswitchDelay[i]->setVisible(false);
} else {
ui->cswCol3_2->hide();
ui->cswCol4_2->hide();
}
connect(cswlabel[i],SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(csw_customContextMenuRequested(QPoint)));
} else {
csw[i]->hide();
cswlabel[i]->hide();
}
}
} else {
ui->cswitchGB2->hide();
}
updateSwitchesTab();
//connects
for (int i=0; i<num_csw; i++) {
connect(csw[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customSwitchesEdited()));
}
switchEditLock = false;
}
void ModelEdit::tabCustomFunctions()
{
switchEditLock = true;
int num_fsw = GetEepromInterface()->getCapability(CustomFunctions);
QStringList paramarmList;
if (!GetEepromInterface()->getCapability(VoicesAsNumbers)) {
for (int i=0; i<num_fsw; i++) {
if (g_model.funcSw[i].func==FuncPlayPrompt || g_model.funcSw[i].func==FuncBackgroundMusic) {
QString temp = g_model.funcSw[i].paramarm;
if (!temp.isEmpty()) {
if (!paramarmList.contains(temp)) {
paramarmList.append(temp);
}
}
}
}
QSettings settings("companion9x", "companion9x");
QString path=settings.value("sdPath", ".").toString();
path.append("/SOUNDS/");
QString lang=radioData.generalSettings.ttsLanguage;
if (lang.isEmpty())
lang="en";
path.append(lang);
QDir qd(path);
int vml= GetEepromInterface()->getCapability(VoicesMaxLength)+4;
if (qd.exists()) {
QStringList filters;
filters << "*.wav" << "*.WAV";
foreach ( QString file, qd.entryList(filters, QDir::Files) ) {
QFileInfo fi(file);
QString temp=fi.completeBaseName();
if (!paramarmList.contains(temp) && temp.length()<=vml) {
paramarmList.append(temp);
}
}
}
}
for (int i=0; i<num_fsw; i++) {
AssignFunc func = g_model.funcSw[i].func;
QGridLayout *layout = i >= 16 ? ui->fswitchlayout2 : ui->fswitchlayout1;
fswLabel[i] = new QLabel(this);
fswLabel[i]->setFrameStyle(QFrame::Panel | QFrame::Raised);
fswLabel[i]->setSizePolicy(QSizePolicy::MinimumExpanding,QSizePolicy::Fixed);
fswLabel[i]->setContextMenuPolicy(Qt::CustomContextMenu);
fswLabel[i]->setMouseTracking(true);
fswLabel[i]->setProperty("FunctionId", i+1);
fswLabel[i]->setText(tr("CF%1").arg(i+1));
layout->addWidget(fswLabel[i],(i%16)+1,0);
connect(fswLabel[i],SIGNAL(customContextMenuRequested(QPoint)),this,SLOT(fsw_customContextMenuRequested(QPoint)));
fswtchSwtch[i] = new QComboBox(this);
fswtchSwtch[i]->setProperty("functionIndex", i);
connect(fswtchSwtch[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customFunctionEdited()));
layout->addWidget(fswtchSwtch[i],(i%16)+1,1);
populateSwitchCB(fswtchSwtch[i], g_model.funcSw[i].swtch, POPULATE_MSWITCHES|POPULATE_ONOFF);
fswtchFunc[i] = new QComboBox(this);
fswtchFunc[i]->setProperty("functionIndex", i);
connect(fswtchFunc[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customFunctionEdited()));
layout->addWidget(fswtchFunc[i],(i%16)+1,2);
populateFuncCB(fswtchFunc[i], g_model.funcSw[i].func);
QHBoxLayout *paramLayout = new QHBoxLayout();
layout->addLayout(paramLayout, (i%16)+1, 3);
fswtchGVmode[i] = new QComboBox(this);
fswtchGVmode[i]->setProperty("functionIndex", i);
connect(fswtchGVmode[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customFunctionEdited()));
paramLayout->addWidget(fswtchGVmode[i]);
populateGVmodeCB(fswtchGVmode[i], g_model.funcSw[i].adjustMode);
fswtchParamGV[i] = new QCheckBox(this);
fswtchParamGV[i]->setProperty("functionIndex", i);
fswtchParamGV[i]->setText("GV");
fswtchParamGV[i]->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
connect(fswtchParamGV[i],SIGNAL(stateChanged(int)),this,SLOT(customFunctionEdited()));
paramLayout->addWidget(fswtchParamGV[i]);
fswtchParam[i] = new QDoubleSpinBox(this);
fswtchParam[i]->setProperty("functionIndex", i);
fswtchParam[i]->setAccelerated(true);
fswtchParam[i]->setDecimals(0);
connect(fswtchParam[i],SIGNAL(editingFinished()),this,SLOT(customFunctionEdited()));
paramLayout->addWidget(fswtchParam[i]);
fswtchParamT[i] = new QComboBox(this);
fswtchParamT[i]->setProperty("functionIndex", i);
paramLayout->addWidget(fswtchParamT[i]);
populateFuncParamCB(fswtchParamT[i], func, g_model.funcSw[i].param, g_model.funcSw[i].adjustMode);
connect(fswtchParamT[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customFunctionEdited()));
fswtchParamArmT[i] = new QComboBox(this);
fswtchParamArmT[i]->setProperty("functionIndex", i);
populateFuncParamArmTCB(fswtchParamArmT[i],&g_model, g_model.funcSw[i].paramarm, paramarmList);
fswtchParamArmT[i]->setEditable(true);
paramLayout->addWidget(fswtchParamArmT[i]);
connect(fswtchParamArmT[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customFunctionEdited()));
connect(fswtchParamArmT[i],SIGNAL(editTextChanged ( const QString)),this,SLOT(customFunctionEdited()));
#ifdef PHONON
playBT[i] = new QPushButton(this);
playBT[i]->setObjectName(QString("play_%1").arg(i));
playBT[i]->setIcon(QIcon(":/images/play.png"));
paramLayout->addWidget(playBT[i]);
connect(playBT[i],SIGNAL(pressed()),this,SLOT(playMusic()));
#endif
QHBoxLayout *repeatLayout = new QHBoxLayout();
layout->addLayout(repeatLayout, (i%16)+1, 4);
fswtchRepeat[i] = new QComboBox(this);
fswtchRepeat[i]->setProperty("functionIndex", i);
connect(fswtchRepeat[i],SIGNAL(currentIndexChanged(int)),this,SLOT(customFunctionEdited()));
repeatLayout->addWidget(fswtchRepeat[i],(i%16)+1);
populateRepeatCB(fswtchRepeat[i], g_model.funcSw[i].repeatParam);
fswtchEnable[i] = new QCheckBox(this);
fswtchEnable[i]->setProperty("functionIndex", i);
fswtchEnable[i]->setText(tr("ON"));
repeatLayout->addWidget(fswtchEnable[i],(i%16)+1);
fswtchEnable[i]->setChecked(g_model.funcSw[i].enabled);
connect(fswtchEnable[i],SIGNAL(stateChanged(int)),this,SLOT(customFunctionEdited()));
refreshCustomFunction(i);
}
if (num_fsw <= 16) {
ui->FSwitchGB2->hide();
}
switchEditLock = false;
}
void ModelEdit::tabSafetySwitches()
{
for(int i=0; i<NUM_SAFETY_CHNOUT; i++)
{
safetySwitchSwtch[i] = new QComboBox(this);
populateSwitchCB(safetySwitchSwtch[i],g_model.safetySw[i].swtch);
ui->grid_tabSafetySwitches->addWidget(safetySwitchSwtch[i],i+1,1);
connect(safetySwitchSwtch[i],SIGNAL(currentIndexChanged(int)),this,SLOT(safetySwitchesEdited()));
safetySwitchValue[i] = new QSpinBox(this);
safetySwitchValue[i]->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
safetySwitchValue[i]->setMaximum(125);
safetySwitchValue[i]->setMinimum(-125);
safetySwitchValue[i]->setAccelerated(true);
safetySwitchValue[i]->setValue(g_model.safetySw[i].val);
ui->grid_tabSafetySwitches->addWidget(safetySwitchValue[i],i+1,2);
connect(safetySwitchValue[i],SIGNAL(editingFinished()),this,SLOT(safetySwitchesEdited()));
}
}
void ModelEdit::customFieldEdited()
{
if (telemetryLock) return;
int cols=GetEepromInterface()->getCapability(TelemetryColsCSFields);
if (cols==0) cols=2;
for (int i=0; i<GetEepromInterface()->getCapability(TelemetryCSFields); i++) {
int screen=i/(4*cols);
int r=((i%(4*cols))%4);
int c=((i%(4*cols))/4);
if (g_model.frsky.screens[screen].type==0) {
g_model.frsky.screens[screen].body.lines[r].source[c]=csf[i]->currentIndex();
}
}
updateSettings();
}
void ModelEdit::customSwitchesEdited()
{
if(switchEditLock) return;
switchEditLock = true;
int i=-1;
QString indextext=sender()->property("index").toString();
if (!indextext.isEmpty()) {
i=indextext.toInt();
} else {
// should not happen
switchEditLock = false;
return;
}
bool chAr;
float value, step;
int newval;
chAr = (getCSFunctionFamily(g_model.customSw[i].func) != getCSFunctionFamily(csw[i]->itemData(csw[i]->currentIndex()).toInt()));
g_model.customSw[i].func = csw[i]->itemData(csw[i]->currentIndex()).toInt();
if(chAr) {
if (getCSFunctionFamily(g_model.customSw[i].func)==CS_FAMILY_TIMERS) {
g_model.customSw[i].val1 = -119;
g_model.customSw[i].val2 = -119;
} else {
g_model.customSw[i].val1 = 0;
g_model.customSw[i].val2 = 0;
}
g_model.customSw[i].andsw = 0;
setSwitchWidgetVisibility(i);
}
if (GetEepromInterface()->getCapability(CustomSwitchesExt)) {
g_model.customSw[i].duration= (uint8_t)round(cswitchDuration[i]->value()*2);
g_model.customSw[i].delay= (uint8_t)round(cswitchDelay[i]->value()*2);
}
RawSource source;
switch (getCSFunctionFamily(g_model.customSw[i].func))
{
case (CS_FAMILY_VOFS):
if (g_model.customSw[i].val1 != cswitchSource1[i]->itemData(cswitchSource1[i]->currentIndex()).toInt()) {
source=RawSource(g_model.customSw[i].val1);
g_model.customSw[i].val1 = cswitchSource1[i]->itemData(cswitchSource1[i]->currentIndex()).toInt();
RawSource newSource = RawSource(g_model.customSw[i].val1);
if (newSource.type == SOURCE_TYPE_TELEMETRY) {
if (g_model.customSw[i].func>CS_FN_ELESS && g_model.customSw[i].func<CS_FN_VEQUAL) {
g_model.customSw[i].val2 = 0;
} else {
g_model.customSw[i].val2 = -128;
}
} else {
if (g_model.customSw[i].func>CS_FN_ELESS && g_model.customSw[i].func<CS_FN_VEQUAL) {
g_model.customSw[i].val2 = (cswitchOffset[i]->value()/source.getStep(g_model));
} else {
g_model.customSw[i].val2 = ((cswitchOffset[i]->value()-source.getOffset(g_model))/source.getStep(g_model))-source.getRawOffset(g_model);
}
}
setSwitchWidgetVisibility(i);
} else {
source=RawSource(g_model.customSw[i].val1);
if (g_model.customSw[i].func>CS_FN_ELESS && g_model.customSw[i].func<CS_FN_VEQUAL) {
g_model.customSw[i].val2 = (cswitchOffset[i]->value()/source.getStep(g_model));
cswitchOffset[i]->setValue(g_model.customSw[i].val2*source.getStep(g_model));
} else {
g_model.customSw[i].val2 = ((cswitchOffset[i]->value()-source.getOffset(g_model))/source.getStep(g_model))-source.getRawOffset(g_model);
cswitchOffset[i]->setValue((g_model.customSw[i].val2 +source.getRawOffset(g_model))*source.getStep(g_model)+source.getOffset(g_model));
}
}
break;
case (CS_FAMILY_TIMERS): {
value=cswitchOffset[i]->value();
newval=TimToVal(value);
if (newval>g_model.customSw[i].val2) {
if (value >=60) {
value=round(value);
step=1;
} else if (value>=2) {
value=(round(value*2.0)/2);
step=0.5;
} else {
step=0.1;
}
} else {
if (value <=2) {
step=0.1;
} else if (value<=60) {
value=(round(value*2.0)/2);
step=0.5;
} else {
value=round(value);
step=1;
}
}
g_model.customSw[i].val2=TimToVal(value);
value=ValToTim(g_model.customSw[i].val2);
cswitchOffset[i]->setValue(value);
cswitchOffset[i]->setSingleStep(step);
value=cswitchValue[i]->value();
newval=TimToVal(value);
if (newval>g_model.customSw[i].val1) {
if (value >=60) {
value=round(value);
step=1;
} else if (value>=2) {
value=(round(value*2.0)/2);
step=0.5;
} else {
step=0.1;
}
} else {
if (value <=2) {
step=0.1;
} else if (value<=60) {
value=(round(value*2.0)/2);
step=0.5;
} else {
value=round(value);
step=1;
}
}
g_model.customSw[i].val1=TimToVal(value);
value=ValToTim(g_model.customSw[i].val1);
cswitchValue[i]->setValue(value);
cswitchValue[i]->setSingleStep(step);
break;
}
case (CS_FAMILY_VBOOL):
case (CS_FAMILY_VCOMP):
g_model.customSw[i].val1 = cswitchSource1[i]->itemData(cswitchSource1[i]->currentIndex()).toInt();
g_model.customSw[i].val2 = cswitchSource2[i]->itemData(cswitchSource2[i]->currentIndex()).toInt();
break;
}
g_model.customSw[i].andsw = cswitchAnd[i]->itemData(cswitchAnd[i]->currentIndex()).toInt();
updateSettings();
switchEditLock = false;
}
#ifdef PHONON
void ModelEdit::mediaPlayer_state(Phonon::State newState, Phonon::State oldState)
{
if (phononLock)
return;
phononLock=true;
if ((newState==Phonon::StoppedState || newState==Phonon::PausedState) && oldState==Phonon::PlayingState) {
clickObject->stop();
clickObject->clearQueue();
clickObject->clear();
for (int i=0; i<GetEepromInterface()->getCapability(CustomFunctions); i++) {
playBT[i]->setObjectName(QString("play_%1").arg(i));
playBT[i]->setIcon(QIcon(":/images/play.png"));
}
}
if (newState==Phonon::ErrorState) {
clickObject->stop();
clickObject->clearQueue();
clickObject->clear();
for (int i=0; i<GetEepromInterface()->getCapability(CustomFunctions); i++) {
playBT[i]->setObjectName(QString("play_%1").arg(i));
playBT[i]->setIcon(QIcon(":/images/play.png"));
}
}
phononLock=false;
}
#endif
void ModelEdit::playMusic()
{
QPushButton *playButton = qobject_cast<QPushButton*>(sender());
int index=playButton->objectName().mid(5,2).toInt();
QString function=playButton->objectName().left(4);
QSettings settings("companion9x", "companion9x");
QString path=settings.value("sdPath", ".").toString();
QDir qd(path);
QString track;
if (qd.exists()) {
if (GetEepromInterface()->getCapability(VoicesAsNumbers)) {
track=path+QString("/%1.wav").arg(int(fswtchParam[index]->value()),4,10,(const QChar)'0');
} else {
path.append("/SOUNDS/");
QString lang=radioData.generalSettings.ttsLanguage;
if (lang.isEmpty())
lang="en";
path.append(lang);
if (fswtchParamArmT[index]->currentText()!="----") {
track=path+"/"+fswtchParamArmT[index]->currentText()+".wav";
}
}
QFile file(track);
if (!file.exists()) {
QMessageBox::critical(this, tr("Error"), tr("Unable to find sound file %1!").arg(track));
track.clear();
}
#ifdef PHONON
if (function=="play" && !track.isEmpty()) {
clickObject->clear();
clickObject->setCurrentSource(Phonon::MediaSource(track));
clickObject->play();
playBT[index]->setObjectName(QString("stop_%1").arg(index));
playBT[index]->setIcon(QIcon(":/images/stop.png"));
} else {
clickObject->stop();
clickObject->clear();
playBT[index]->setObjectName(QString("play_%1").arg(index));
playBT[index]->setIcon(QIcon(":/images/play.png"));
}
#endif
}
}
#define CUSTOM_FUNCTION_NUMERIC_PARAM (1<<0)
#define CUSTOM_FUNCTION_SOURCE_PARAM (1<<1)
#define CUSTOM_FUNCTION_FILE_PARAM (1<<2)
#define CUSTOM_FUNCTION_GV_MODE (1<<3)
#define CUSTOM_FUNCTION_GV_TOOGLE (1<<4)
#define CUSTOM_FUNCTION_ENABLE (1<<5)
#define CUSTOM_FUNCTION_REPEAT (1<<6)
#define CUSTOM_FUNCTION_PLAY (1<<7)
void ModelEdit::customFunctionEdited()
{
if (switchEditLock) return;
switchEditLock = true;
int index = sender()->property("functionIndex").toInt();
refreshCustomFunction(index, true);
updateSettings();
switchEditLock = false;
}
void ModelEdit::refreshCustomFunction(int i, bool modified)
{
unsigned int widgetsMask = 0;
if (modified) {
g_model.funcSw[i].swtch = RawSwitch(fswtchSwtch[i]->itemData(fswtchSwtch[i]->currentIndex()).toInt());
g_model.funcSw[i].func = (AssignFunc)fswtchFunc[i]->currentIndex();
g_model.funcSw[i].enabled =fswtchEnable[i]->isChecked();
g_model.funcSw[i].repeatParam = (AssignFunc)fswtchRepeat[i]->currentIndex();
g_model.funcSw[i].adjustMode = (AssignFunc)fswtchGVmode[i]->currentIndex();
}
int index = fswtchFunc[i]->currentIndex();
if (index>=FuncSafetyCh1 && index<=FuncSafetyCh16) {
fswtchParam[i]->setDecimals(0);
fswtchParam[i]->setSingleStep(1);
fswtchParam[i]->setMinimum(-125);
fswtchParam[i]->setMaximum(125);
if (modified) {
g_model.funcSw[i].param = fswtchParam[i]->value();
}
fswtchParam[i]->setValue(g_model.funcSw[i].param);
widgetsMask |= CUSTOM_FUNCTION_NUMERIC_PARAM + CUSTOM_FUNCTION_ENABLE;
} else if (index==FuncLogs) {
fswtchParam[i]->setDecimals(1);
fswtchParam[i]->setMinimum(0);
fswtchParam[i]->setMaximum(25.5);
fswtchParam[i]->setSingleStep(0.1);
if (modified) g_model.funcSw[i].param = fswtchParam[i]->value()*10.0;
fswtchParam[i]->setValue(g_model.funcSw[i].param/10.0);
widgetsMask |= CUSTOM_FUNCTION_NUMERIC_PARAM + CUSTOM_FUNCTION_ENABLE;
} else if (index>=FuncAdjustGV1 && index<=FuncAdjustGV5) {
if (modified) g_model.funcSw[i].adjustMode = fswtchGVmode[i]->currentIndex();
widgetsMask |= CUSTOM_FUNCTION_GV_MODE + CUSTOM_FUNCTION_ENABLE;
if (g_model.funcSw[i].adjustMode==0) {
if (modified) g_model.funcSw[i].param = fswtchParam[i]->value();
fswtchParam[i]->setDecimals(0);
fswtchParam[i]->setSingleStep(1);
fswtchParam[i]->setMinimum(-125);
fswtchParam[i]->setMaximum(125);
fswtchParam[i]->setValue(g_model.funcSw[i].param);
widgetsMask |= CUSTOM_FUNCTION_NUMERIC_PARAM;
} else {
if (modified) g_model.funcSw[i].param = fswtchParamT[i]->itemData(fswtchParamT[i]->currentIndex()).toInt();
populateFuncParamCB(fswtchParamT[i], index, g_model.funcSw[i].param, g_model.funcSw[i].adjustMode);
widgetsMask |= CUSTOM_FUNCTION_SOURCE_PARAM;
}
} else if (index==FuncReset) {
if (modified) g_model.funcSw[i].param = (uint8_t)fswtchParamT[i]->currentIndex();
populateFuncParamCB(fswtchParamT[i], index, g_model.funcSw[i].param);
widgetsMask |= CUSTOM_FUNCTION_SOURCE_PARAM;
} else if (index==FuncVolume) {
if (modified) g_model.funcSw[i].param = fswtchParamT[i]->itemData(fswtchParamT[i]->currentIndex()).toInt();
populateFuncParamCB(fswtchParamT[i], index, g_model.funcSw[i].param);
widgetsMask |= CUSTOM_FUNCTION_SOURCE_PARAM + CUSTOM_FUNCTION_ENABLE;
} else if (index==FuncPlaySound || index==FuncPlayHaptic || index==FuncPlayValue || index==FuncPlayPrompt || index==FuncPlayBoth || index==FuncBackgroundMusic) {
if (modified) g_model.funcSw[i].repeatParam = fswtchRepeat[i]->itemData(fswtchRepeat[i]->currentIndex()).toInt();
if (index != FuncBackgroundMusic) {
if (GetEepromInterface()->getCapability(HasFuncRepeat)) {
widgetsMask |= CUSTOM_FUNCTION_REPEAT;
}
}
if (index==FuncPlayValue) {
if (modified) g_model.funcSw[i].param = fswtchParamT[i]->itemData(fswtchParamT[i]->currentIndex()).toInt();
populateFuncParamCB(fswtchParamT[i], index, g_model.funcSw[i].param);
widgetsMask |= CUSTOM_FUNCTION_SOURCE_PARAM + CUSTOM_FUNCTION_REPEAT;
} else if (index==FuncPlayPrompt || index==FuncPlayBoth) {
if (GetEepromInterface()->getCapability(VoicesAsNumbers)) {
fswtchParam[i]->setDecimals(0);
fswtchParam[i]->setSingleStep(1);
fswtchParam[i]->setMinimum(0);
if (index==FuncPlayPrompt) {
widgetsMask |= CUSTOM_FUNCTION_NUMERIC_PARAM + CUSTOM_FUNCTION_REPEAT + CUSTOM_FUNCTION_GV_TOOGLE;
} else {
widgetsMask |= CUSTOM_FUNCTION_NUMERIC_PARAM + CUSTOM_FUNCTION_REPEAT;
fswtchParamGV[i]->setChecked(false);
}
fswtchParam[i]->setMaximum(index==FuncPlayBoth ? 254 : 255);
if (modified) {
if (fswtchParamGV[i]->isChecked()) {
fswtchParam[i]->setMinimum(1);
g_model.funcSw[i].param = std::min(fswtchParam[i]->value(),5.0)+(fswtchParamGV[i]->isChecked() ? 250 : 0);
} else {
g_model.funcSw[i].param = fswtchParam[i]->value();
}
}
if (g_model.funcSw[i].param>250 && (index!=FuncPlayBoth)) {
fswtchParamGV[i]->setChecked(true);
fswtchParam[i]->setValue(g_model.funcSw[i].param-250);
fswtchParam[i]->setMaximum(5);
} else {
fswtchParamGV[i]->setChecked(false);
fswtchParam[i]->setValue(g_model.funcSw[i].param);
}
if (g_model.funcSw[i].param < 251)
widgetsMask |= CUSTOM_FUNCTION_PLAY;
} else {
widgetsMask |= CUSTOM_FUNCTION_FILE_PARAM;
if (modified) {
memset(g_model.funcSw[i].paramarm, 0, sizeof(g_model.funcSw[i].paramarm));
int vml=GetEepromInterface()->getCapability(VoicesMaxLength);
if (fswtchParamArmT[i]->currentText() != "----") {
widgetsMask |= CUSTOM_FUNCTION_PLAY;
for (int j=0; j<std::min(fswtchParamArmT[i]->currentText().length(),vml); j++) {
g_model.funcSw[i].paramarm[j] = fswtchParamArmT[i]->currentText().toAscii().at(j);
}
}
}
}
} else if (index==FuncBackgroundMusic) {
widgetsMask |= CUSTOM_FUNCTION_FILE_PARAM;
if (modified) {
memset(g_model.funcSw[i].paramarm, 0, sizeof(g_model.funcSw[i].paramarm));
int vml=GetEepromInterface()->getCapability(VoicesMaxLength);
if (fswtchParamArmT[i]->currentText() != "----") {
widgetsMask |= CUSTOM_FUNCTION_PLAY;
for (int j=0; j<std::min(fswtchParamArmT[i]->currentText().length(),vml); j++) {
g_model.funcSw[i].paramarm[j] = fswtchParamArmT[i]->currentText().toAscii().at(j);
}
}
}
} else if (index==FuncPlaySound) {
if (modified) g_model.funcSw[i].param = (uint8_t)fswtchParamT[i]->currentIndex();
populateFuncParamCB(fswtchParamT[i], index, g_model.funcSw[i].param);
widgetsMask |= CUSTOM_FUNCTION_SOURCE_PARAM;
} else if (index==FuncPlayHaptic) {
if (modified) g_model.funcSw[i].param = (uint8_t)fswtchParamT[i]->currentIndex();
populateFuncParamCB(fswtchParamT[i], index, g_model.funcSw[i].param);
widgetsMask |= CUSTOM_FUNCTION_SOURCE_PARAM;
}
} else if (g_model.funcSw[i].swtch.type!=SWITCH_TYPE_NONE) {
if (modified) g_model.funcSw[i].param = fswtchParam[i]->value();
fswtchParam[i]->setDecimals(0);
fswtchParam[i]->setSingleStep(1);
fswtchParam[i]->setValue(g_model.funcSw[i].param);
if (index<=FuncInstantTrim) {
widgetsMask |= CUSTOM_FUNCTION_ENABLE;
}
}
fswtchParam[i]->setVisible(widgetsMask & CUSTOM_FUNCTION_NUMERIC_PARAM);
fswtchParamGV[i]->setVisible(widgetsMask & CUSTOM_FUNCTION_GV_TOOGLE);
fswtchParamT[i]->setVisible(widgetsMask & CUSTOM_FUNCTION_SOURCE_PARAM);
fswtchParamArmT[i]->setVisible(widgetsMask & CUSTOM_FUNCTION_FILE_PARAM);
fswtchEnable[i]->setVisible(widgetsMask & CUSTOM_FUNCTION_ENABLE);
if (!(widgetsMask & CUSTOM_FUNCTION_ENABLE)) fswtchEnable[i]->setChecked(false);
fswtchRepeat[i]->setVisible(widgetsMask & CUSTOM_FUNCTION_REPEAT);
fswtchGVmode[i]->setVisible(widgetsMask & CUSTOM_FUNCTION_GV_MODE);
#ifdef PHONON
playBT[i]->setVisible(widgetsMask & CUSTOM_FUNCTION_PLAY);
#endif
}
void ModelEdit::tabTelemetry()
{
QSettings settings("companion9x", "companion9x");
QString firmware_id = settings.value("firmware", default_firmware_variant.id).toString();
float a1ratio;
float a2ratio;
QGroupBox* barsgb[3] = { ui->CS1Bars, ui->CS2Bars, ui->CS3Bars };
QGroupBox* numsgb[3] = { ui->CS1Nums, ui->CS2Nums, ui->CS3Nums };
QComboBox* barscb[12] = { ui->telBarCS1B1_CB, ui->telBarCS1B2_CB, ui->telBarCS1B3_CB, ui->telBarCS1B4_CB,
ui->telBarCS2B1_CB, ui->telBarCS2B2_CB, ui->telBarCS2B3_CB, ui->telBarCS2B4_CB,
ui->telBarCS3B1_CB, ui->telBarCS3B2_CB, ui->telBarCS3B3_CB, ui->telBarCS3B4_CB};
QDoubleSpinBox* minsb[12] = { ui->telMinCS1SB1, ui->telMinCS1SB2, ui->telMinCS1SB3, ui->telMinCS1SB4,
ui->telMinCS2SB1, ui->telMinCS2SB2, ui->telMinCS2SB3, ui->telMinCS2SB4,
ui->telMinCS3SB1, ui->telMinCS3SB2, ui->telMinCS3SB3, ui->telMinCS3SB4};
QDoubleSpinBox* maxsb[12] = { ui->telMaxCS1SB1, ui->telMaxCS1SB2, ui->telMaxCS1SB3, ui->telMaxCS1SB4,
ui->telMaxCS2SB1, ui->telMaxCS2SB2, ui->telMaxCS2SB3, ui->telMaxCS2SB4,
ui->telMaxCS3SB1, ui->telMaxCS3SB2, ui->telMaxCS3SB3, ui->telMaxCS3SB4};
QComboBox* tmp[36] = { ui->telemetryCS1F1_CB, ui->telemetryCS1F2_CB, ui->telemetryCS1F3_CB, ui->telemetryCS1F4_CB, ui->telemetryCS1F5_CB, ui->telemetryCS1F6_CB, ui->telemetryCS1F7_CB, ui->telemetryCS1F8_CB, ui->telemetryCS1F9_CB, ui->telemetryCS1F10_CB, ui->telemetryCS1F11_CB, ui->telemetryCS1F12_CB,
ui->telemetryCS2F1_CB, ui->telemetryCS2F2_CB, ui->telemetryCS2F3_CB, ui->telemetryCS2F4_CB, ui->telemetryCS2F5_CB, ui->telemetryCS2F6_CB, ui->telemetryCS2F7_CB, ui->telemetryCS2F8_CB, ui->telemetryCS2F9_CB, ui->telemetryCS2F10_CB, ui->telemetryCS2F11_CB, ui->telemetryCS2F12_CB,
ui->telemetryCS3F1_CB, ui->telemetryCS3F2_CB, ui->telemetryCS3F3_CB, ui->telemetryCS3F4_CB, ui->telemetryCS3F5_CB, ui->telemetryCS3F6_CB, ui->telemetryCS3F7_CB, ui->telemetryCS3F8_CB, ui->telemetryCS3F9_CB, ui->telemetryCS3F10_CB, ui->telemetryCS3F11_CB, ui->telemetryCS3F12_CB};
memcpy(barsGB, barsgb, sizeof(barsGB));
memcpy(numsGB, numsgb, sizeof(numsGB));
memcpy(barsCB, barscb, sizeof(barsCB));
memcpy(maxSB, maxsb, sizeof(maxSB));
memcpy(minSB, minsb, sizeof(minSB));
memcpy(csf, tmp, sizeof(csf));
telemetryLock=true;
ui->telemetryCSType1->setCurrentIndex(g_model.frsky.screens[0].type);
ui->telemetryCSType2->setCurrentIndex(g_model.frsky.screens[1].type);
ui->telemetryCSType3->setCurrentIndex(g_model.frsky.screens[2].type);
for (int i=0; i<3; i++) {
bool isNum = (g_model.frsky.screens[i].type==0);
barsGB[i]->setVisible(!isNum);
numsGB[i]->setVisible(isNum);
}
connect(ui->telemetryCSType1,SIGNAL(currentIndexChanged(int)),this,SLOT(ScreenTypeCBcurrentIndexChanged(int)));
connect(ui->telemetryCSType2,SIGNAL(currentIndexChanged(int)),this,SLOT(ScreenTypeCBcurrentIndexChanged(int)));
connect(ui->telemetryCSType3,SIGNAL(currentIndexChanged(int)),this,SLOT(ScreenTypeCBcurrentIndexChanged(int)));
//frsky Settings
if (!GetEepromInterface()->getCapability(TelemetryRSSIModel) ) {
ui->RSSIGB->hide();
}
ui->rssiAlarm1SB->setValue(g_model.frsky.rssiAlarms[0].value);
ui->rssiAlarm2SB->setValue(g_model.frsky.rssiAlarms[1].value);
ui->rssiAlarm1CB->setCurrentIndex(g_model.frsky.rssiAlarms[0].level);
ui->rssiAlarm2CB->setCurrentIndex(g_model.frsky.rssiAlarms[1].level);
if (!GetEepromInterface()->getCapability(HasAltitudeSel)) {
ui->AltitudeGPS_ChkB->hide();
} else {
ui->AltitudeGPS_ChkB->setChecked(g_model.frsky.FrSkyGpsAlt);
}
int varioCap=GetEepromInterface()->getCapability(HasVario);
// if (IS_TARANIS(GetEepromInterface()->getBoard())) {
if (false) {
ui->AltitudeToolbar_ChkB->setChecked(g_model.frsky.altitudeDisplayed);
} else {
ui->AltitudeToolbar_ChkB->hide();
}
if (!varioCap) {
ui->varioLimitMax_DSB->hide();
ui->varioLimitMinOff_ChkB->hide();
ui->varioLimitMin_DSB->hide();
ui->varioLimitCenterMin_DSB->hide();
ui->varioLimitCenterMax_DSB->hide();
ui->varioLimit_label->hide();
ui->VarioLabel_1->hide();
ui->VarioLabel_2->hide();
ui->VarioLabel_3->hide();
ui->VarioLabel_4->hide();
ui->varioSourceCB->hide();
ui->varioSource_label->hide();
} else {
if (!GetEepromInterface()->getCapability(HasVarioSink)) {
ui->varioLimitMinOff_ChkB->hide();
ui->varioLimitMin_DSB->hide();
ui->varioLimitCenterMin_DSB->hide();
ui->VarioLabel_1->hide();
ui->VarioLabel_2->hide();
}
ui->varioLimitMin_DSB->setValue(g_model.frsky.varioMin-10);
ui->varioLimitMax_DSB->setValue(g_model.frsky.varioMax+10);
ui->varioLimitCenterMax_DSB->setValue((g_model.frsky.varioCenterMax/10.0)+0.5);
ui->varioSourceCB->setCurrentIndex(g_model.frsky.varioSource);
if (g_model.frsky.varioCenterMin==-16) {
ui->varioLimitMinOff_ChkB->setChecked(true);
ui->varioLimitCenterMin_DSB->setValue(-2.0);
ui->varioLimitCenterMin_DSB->setDisabled(true);
} else {
ui->varioLimitMinOff_ChkB->setChecked(false);
ui->varioLimitCenterMin_DSB->setValue((g_model.frsky.varioCenterMin/10.0)-0.5);
}
int mask=1;
for (int i=0; i< ui->varioSourceCB->count(); i++) {
if (!(varioCap&mask)) {
QModelIndex index = ui->varioSourceCB->model()->index(i, 0);
QVariant v(0);
ui->varioSourceCB->model()->setData(index, v, Qt::UserRole - 1);
}
mask <<=1;
}
}
if (!(GetEepromInterface()->getCapability(HasAltitudeSel)||GetEepromInterface()->getCapability(HasVario))) {
ui->altimetryGB->hide();
}
if (GetEepromInterface()->getCapability(NoTelemetryProtocol)) {
g_model.frsky.usrProto=1;
ui->frskyProtoCB->setDisabled(true);
} else {
ui->frskyProtoCB->setEnabled(true);
}
if (GetEepromInterface()->getCapability(TelemetryCSFields)==0) {
ui->groupBox_5->hide();
} else {
if (GetEepromInterface()->getCapability(TelemetryCSFields)==8) {
ui->tabCsView->removeTab(1);
ui->tabCsView->removeTab(2);
}
if (GetEepromInterface()->getCapability(TelemetryCSFields)==16) {
ui->tabCsView->removeTab(2);
}
int cols=GetEepromInterface()->getCapability(TelemetryColsCSFields);
if (cols==0) cols=2;
for (int screen=0; screen<(GetEepromInterface()->getCapability(TelemetryCSFields)/(4*cols)); screen++) {
for (int c=0; c<cols; c++) {
for (int r=0; r<4; r++) {
int index=screen*12+c*4+r;
if (g_model.frsky.screens[screen].type==0) {
populateCustomScreenFieldCB(csf[index], g_model.frsky.screens[screen].body.lines[r].source[c], (r<4), g_model.frsky.usrProto);
} else {
populateCustomScreenFieldCB(csf[index], 0, (r<4), g_model.frsky.usrProto);
}
connect(csf[index],SIGNAL(currentIndexChanged(int)),this,SLOT(customFieldEdited()));
}
}
for (int c=cols; c<3; c++) {
for (int r=0; r<4; r++) {
int index=screen*12+c*4+r;
csf[index]->hide();
}
}
}
}
if (!GetEepromInterface()->getCapability(TelemetryUnits)) {
ui->frskyUnitsCB->setDisabled(true);
int index=0;
if (firmware_id.contains("imperial")) {
index=1;
}
ui->frskyUnitsCB->setCurrentIndex(index);
}
if ((GetEepromInterface()->getCapability(Telemetry)&TM_HASWSHH)) {
ui->frskyProtoCB->addItem(tr("Winged Shadow How High"));
} else {
ui->frskyProtoCB->addItem(tr("Winged Shadow How High (not supported)"));
}
ui->a1UnitCB->setCurrentIndex(g_model.frsky.channels[0].type);
if (g_model.frsky.channels[0].type==0 || g_model.frsky.channels[0].type==1 || g_model.frsky.channels[0].type==2) {
a1ratio=(g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier)/10.0;
ui->a1RatioSB->setDecimals(1);
ui->a1RatioSB->setMaximum(25.5*GetEepromInterface()->getCapability(TelemetryMaxMultiplier));
} else {
a1ratio=g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier;
ui->a1RatioSB->setDecimals(0);
ui->a1RatioSB->setMaximum(255*GetEepromInterface()->getCapability(TelemetryMaxMultiplier));
}
ui->a1RatioSB->setValue(a1ratio);
updateA1Fields();
if (g_model.frsky.channels[1].type==0 || g_model.frsky.channels[1].type==1 || g_model.frsky.channels[1].type==2) {
a2ratio=(g_model.frsky.channels[1].ratio<<g_model.frsky.channels[1].multiplier)/10.0;
ui->a2RatioSB->setDecimals(1);
ui->a2RatioSB->setMaximum(25.5*GetEepromInterface()->getCapability(TelemetryMaxMultiplier));
} else {
a2ratio=g_model.frsky.channels[1].ratio<<g_model.frsky.channels[1].multiplier;
ui->a2RatioSB->setDecimals(0);
ui->a2RatioSB->setMaximum(255*GetEepromInterface()->getCapability(TelemetryMaxMultiplier));
}
ui->a2RatioSB->setValue(a2ratio);
updateA2Fields();
ui->a11LevelCB->setCurrentIndex(g_model.frsky.channels[0].alarms[0].level);
ui->a11GreaterCB->setCurrentIndex(g_model.frsky.channels[0].alarms[0].greater);
ui->a12LevelCB->setCurrentIndex(g_model.frsky.channels[0].alarms[1].level);
ui->a12GreaterCB->setCurrentIndex(g_model.frsky.channels[0].alarms[1].greater);
ui->a2UnitCB->setCurrentIndex(g_model.frsky.channels[1].type);
ui->a21LevelCB->setCurrentIndex(g_model.frsky.channels[1].alarms[0].level);
ui->a21GreaterCB->setCurrentIndex(g_model.frsky.channels[1].alarms[0].greater);
ui->a22LevelCB->setCurrentIndex(g_model.frsky.channels[1].alarms[1].level);
ui->a22GreaterCB->setCurrentIndex(g_model.frsky.channels[1].alarms[1].greater);
if (!(GetEepromInterface()->getCapability(Telemetry)&TM_HASOFFSET)) {
ui->a1CalibSB->hide();
ui->a2CalibSB->hide();
ui->a1CalibLabel->hide();
ui->a2CalibLabel->hide();
} else {
ui->label_A1Max->setText(tr("Range"));
ui->label_A2Max->setText(tr("Range"));
}
ui->frskyProtoCB->setCurrentIndex(g_model.frsky.usrProto);
ui->frskyUnitsCB->setCurrentIndex(g_model.frsky.imperial);
ui->frskyBladesCB->setCurrentIndex(g_model.frsky.blades);
ui->frskyCurrentCB->setCurrentIndex(g_model.frsky.currentSource);
ui->frskyVoltCB->setCurrentIndex(g_model.frsky.voltsSource);
for (int screen=0; screen<2;screen++) {
for (int rows=0; rows<4; rows++) {
for (int cols=0; cols<3; cols++) {
int index=screen*12+cols*4+rows;
populateCustomScreenFieldCB(csf[index], g_model.frsky.screens[screen].body.lines[rows].source[cols], (rows<4), g_model.frsky.usrProto);
}
}
}
for (int j=0; j<12; j++) {
int screen = j/4;
int field = j%4;
populateCustomScreenFieldCB(barsCB[j], g_model.frsky.screens[screen].body.bars[field].source, false, g_model.frsky.usrProto);
switch (g_model.frsky.screens[screen].body.bars[field].source-1) {
case TELEMETRY_SOURCE_TX_BATT:
case TELEMETRY_SOURCE_A1:
case TELEMETRY_SOURCE_A1_MIN:
case TELEMETRY_SOURCE_A2:
case TELEMETRY_SOURCE_A2_MIN:
case TELEMETRY_SOURCE_CELLS_SUM:
case TELEMETRY_SOURCE_VFAS:
case TELEMETRY_SOURCE_CURRENT_MAX:
case TELEMETRY_SOURCE_CURRENT:
minsb[j]->setDecimals(1);
maxsb[j]->setDecimals(1);
break;
case TELEMETRY_SOURCE_CELL:
minsb[j]->setDecimals(2);
maxsb[j]->setDecimals(2);
break;
default:
minsb[j]->setDecimals(0);
maxsb[j]->setDecimals(0);
}
minsb[j]->setMinimum(getBarValue(g_model.frsky.screens[screen].body.bars[field].source, 0, &g_model.frsky));
minsb[j]->setMaximum(getBarValue(g_model.frsky.screens[screen].body.bars[field].source, 255, &g_model.frsky));
minsb[j]->setSingleStep(getBarStep(g_model.frsky.screens[screen].body.bars[field].source));
minsb[j]->setValue(getBarValue(g_model.frsky.screens[screen].body.bars[field].source, g_model.frsky.screens[screen].body.bars[field].barMin, &g_model.frsky));
maxsb[j]->setMinimum(getBarValue(g_model.frsky.screens[screen].body.bars[field].source, 0, &g_model.frsky));
maxsb[j]->setMaximum(getBarValue(g_model.frsky.screens[screen].body.bars[field].source, 255, &g_model.frsky));
maxsb[j]->setSingleStep(getBarStep(g_model.frsky.screens[screen].body.bars[field].source));
maxsb[j]->setValue(getBarValue(g_model.frsky.screens[screen].body.bars[field].source, (255-g_model.frsky.screens[screen].body.bars[field].barMax), &g_model.frsky));
if (g_model.frsky.screens[screen].body.bars[field].source==0 || g_model.frsky.screens[screen].type==0) {
minsb[j]->setDisabled(true);
maxsb[j]->setDisabled(true);
}
connect(barsCB[j],SIGNAL(currentIndexChanged(int)),this,SLOT(telBarCBcurrentIndexChanged(int)));
connect(maxSB[j],SIGNAL(editingFinished()),this,SLOT(telMaxSBeditingFinished()));
connect(minSB[j],SIGNAL(editingFinished()),this,SLOT(telMinSBeditingFinished()));
}
telemetryLock=false;
}
void ModelEdit::updateA1Fields()
{
float a1ratio,a11value, a12value;
if (g_model.frsky.channels[0].ratio==0) {
ui->a11ValueSB->setMinimum(0);
ui->a11ValueSB->setMaximum(0);
ui->a12ValueSB->setMinimum(0);
ui->a12ValueSB->setMaximum(0);
ui->a1CalibSB->setMinimum(0);
ui->a1CalibSB->setMaximum(0);
ui->a1CalibSB->setValue(0);
ui->a11ValueSB->setValue(0);
ui->a12ValueSB->setValue(0);
return;
}
if (g_model.frsky.channels[0].type==0 || g_model.frsky.channels[0].type==1 || g_model.frsky.channels[0].type==2) {
a1ratio=(g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier)/10.0;
ui->a11ValueSB->setDecimals(2);
ui->a11ValueSB->setSingleStep(a1ratio/255.0);
ui->a12ValueSB->setDecimals(2);
ui->a12ValueSB->setSingleStep(a1ratio/255.0);
ui->a11ValueSB->setMinimum((g_model.frsky.channels[0].ratio*1.0*g_model.frsky.channels[0].offset)/2550.0);
ui->a11ValueSB->setMaximum(a1ratio+(g_model.frsky.channels[0].ratio*1.0*g_model.frsky.channels[0].offset)/2550.0);
ui->a12ValueSB->setMinimum((g_model.frsky.channels[0].offset*1.0*g_model.frsky.channels[0].ratio)/2550.0);
ui->a12ValueSB->setMaximum(a1ratio+(g_model.frsky.channels[0].offset*1.0*g_model.frsky.channels[0].ratio)/2550.0);
} else {
a1ratio=g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier;
ui->a11ValueSB->setDecimals(2);
ui->a11ValueSB->setSingleStep(a1ratio/255.0);
ui->a12ValueSB->setDecimals(2);
ui->a12ValueSB->setSingleStep(a1ratio/255.0);
ui->a11ValueSB->setMinimum((g_model.frsky.channels[0].offset*1.0*g_model.frsky.channels[0].ratio)/255.0);
ui->a11ValueSB->setMaximum(a1ratio+(g_model.frsky.channels[0].offset*1.0*g_model.frsky.channels[0].ratio)/255.0);
ui->a12ValueSB->setMinimum((g_model.frsky.channels[0].offset*1.0*g_model.frsky.channels[0].ratio)/255.0);
ui->a12ValueSB->setMaximum(a1ratio+(g_model.frsky.channels[0].offset*1.0*g_model.frsky.channels[0].ratio)/255.0);
}
ui->a1CalibSB->setDecimals(2);
ui->a1CalibSB->setMaximum((a1ratio*127)/255.0);
ui->a1CalibSB->setMinimum((-a1ratio*128)/255.0);
ui->a1CalibSB->setSingleStep(a1ratio/255.0);
ui->a1CalibSB->setValue((g_model.frsky.channels[0].offset*a1ratio)/255);
a11value=a1ratio*(g_model.frsky.channels[0].alarms[0].value/255.0+g_model.frsky.channels[0].offset/255.0);
a12value=a1ratio*(g_model.frsky.channels[0].alarms[1].value/255.0+g_model.frsky.channels[0].offset/255.0);;
ui->a11ValueSB->setValue(a11value);
ui->a12ValueSB->setValue(a12value);
}
void ModelEdit::updateA2Fields()
{
float a2ratio,a21value, a22value;
if (g_model.frsky.channels[1].ratio==0) {
ui->a21ValueSB->setMinimum(0);
ui->a21ValueSB->setMaximum(0);
ui->a22ValueSB->setMinimum(0);
ui->a22ValueSB->setMaximum(0);
ui->a2CalibSB->setMinimum(0);
ui->a2CalibSB->setMaximum(0);
ui->a2CalibSB->setValue(0);
ui->a21ValueSB->setValue(0);
ui->a22ValueSB->setValue(0);
return;
}
if (g_model.frsky.channels[1].type==0) {
a2ratio=g_model.frsky.channels[1].ratio/10.0;
ui->a21ValueSB->setDecimals(2);
ui->a21ValueSB->setSingleStep(a2ratio/255.0);
ui->a22ValueSB->setDecimals(2);
ui->a22ValueSB->setSingleStep(a2ratio/255.0);
ui->a21ValueSB->setMinimum((g_model.frsky.channels[1].offset*1.0*g_model.frsky.channels[1].ratio)/2550.0);
ui->a21ValueSB->setMaximum(a2ratio+(g_model.frsky.channels[1].offset*1.0*g_model.frsky.channels[1].ratio)/2550.0);
ui->a22ValueSB->setMinimum((g_model.frsky.channels[1].offset*1.0*g_model.frsky.channels[1].ratio*1.0)/2550.0);
ui->a22ValueSB->setMaximum(a2ratio+(g_model.frsky.channels[1].offset*1.0*g_model.frsky.channels[1].ratio)/2550.0);
} else {
a2ratio=g_model.frsky.channels[1].ratio;
ui->a21ValueSB->setDecimals(2);
ui->a21ValueSB->setSingleStep(a2ratio/255.0);
ui->a22ValueSB->setDecimals(2);
ui->a22ValueSB->setSingleStep(a2ratio/255.0);
ui->a21ValueSB->setMinimum((g_model.frsky.channels[1].offset*1.0*g_model.frsky.channels[1].ratio)/255.0);
ui->a21ValueSB->setMaximum(a2ratio+(g_model.frsky.channels[1].offset*1.0*g_model.frsky.channels[1].ratio)/255.0);
ui->a22ValueSB->setMinimum((g_model.frsky.channels[1].offset*1.0*g_model.frsky.channels[1].ratio)/255.0);
ui->a22ValueSB->setMaximum(a2ratio+(g_model.frsky.channels[1].offset*1.0*g_model.frsky.channels[1].ratio)/255.0);
}
ui->a2CalibSB->setDecimals(2);
ui->a2CalibSB->setMaximum((a2ratio*127)/255.0);
ui->a2CalibSB->setMinimum((-a2ratio*128)/255.0);
ui->a2CalibSB->setSingleStep(a2ratio/255.0);
ui->a2CalibSB->setValue((g_model.frsky.channels[1].offset*a2ratio)/255.0);
a21value=a2ratio*(g_model.frsky.channels[1].alarms[0].value/255.0+g_model.frsky.channels[1].offset/255.0);
a22value=a2ratio*(g_model.frsky.channels[1].alarms[1].value/255.0+g_model.frsky.channels[1].offset/255.0);
ui->a21ValueSB->setValue(a21value);
ui->a22ValueSB->setValue(a22value);
}
void ModelEdit::tabTemplates()
{
ui->templateList->clear();
ui->templateList->addItem(tr("Simple 4-CH"));
ui->templateList->addItem(tr("T-Cut"));
ui->templateList->addItem(tr("Sticky T-Cut"));
ui->templateList->addItem(tr("V-Tail"));
ui->templateList->addItem(tr("Elevon\\Delta"));
ui->templateList->addItem(tr("Heli Setup"));
ui->templateList->addItem(tr("Heli Setup with gyro gain control"));
ui->templateList->addItem(tr("Gyro gain control"));
ui->templateList->addItem(tr("Heli Setup (Futaba's channel assignment style)"));
ui->templateList->addItem(tr("Heli Setup with gyro gain control (Futaba's channel assignment style)"));
ui->templateList->addItem(tr("Gyro gain control (Futaba's channel assignment style)"));
ui->templateList->addItem(tr("Servo Test"));
ui->templateList->addItem(tr("MultiCopter"));
ui->templateList->addItem(tr("Use Model Config Wizard"));
}
void ModelEdit::on_modelNameLE_editingFinished()
{
int length=ui->modelNameLE->maxLength();
strncpy(g_model.name, ui->modelNameLE->text().toAscii(), length);
updateSettings();
}
void ModelEdit::on_modelImage_CB_currentIndexChanged(int index)
{
if (modelImageLock)
return;
strncpy(g_model.bitmap, ui->modelImage_CB->currentText().toAscii(), GetEepromInterface()->getCapability(VoicesMaxLength));
QSettings settings("companion9x", "companion9x");
QString path=settings.value("sdPath", ".").toString();
path.append("/BMP/");
QDir qd(path);
if (qd.exists()) {
QString fileName=path;
fileName.append(g_model.bitmap);
fileName.append(".bmp");
QImage image(fileName);
if (image.isNull()) {
fileName=path;
fileName.append(g_model.bitmap);
fileName.append(".BMP");
image.load(fileName);
}
if (!image.isNull()) {
ui->modelImage_image->setPixmap(QPixmap::fromImage(image.scaled( 64,32)));;
} else {
ui->modelImage_image->clear();
}
} else {
ui->modelImage_image->clear();
}
updateSettings();
}
void ModelEdit::phaseName_editingFinished()
{
QLineEdit *lineEdit = qobject_cast<QLineEdit*>(sender());
int phase = lineEdit->objectName().mid(5,1).toInt();
QString PhaseName=lineEdit->text();
QString TabName;
if (phase==0) {
TabName.append(QObject::tr("Flight Mode 0 (Default)"));
} else {
TabName.append(QObject::tr("FM %1").arg(phase));
}
if (!PhaseName.isEmpty()) {
TabName.append(" (");
TabName.append(PhaseName);
TabName.append(")");
}
ui->phases->setTabText(phase,TabName);
int length=lineEdit->maxLength();
strncpy(g_model.phaseData[phase].name, lineEdit->text().toAscii(), length);
updateSettings();
}
void ModelEdit::phaseSwitch_currentIndexChanged()
{
QComboBox *comboBox = qobject_cast<QComboBox*>(sender());
int phase = comboBox->objectName().mid(5,1).toInt();
g_model.phaseData[phase].swtch = RawSwitch(comboBox->itemData(comboBox->currentIndex()).toInt());
updateSettings();
}
void ModelEdit::phaseFadeIn_editingFinished()
{
QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox*>(sender());
int phase = spinBox->objectName().mid(5,1).toInt();
int scale=GetEepromInterface()->getCapability(SlowScale);
g_model.phaseData[phase].fadeIn = round(spinBox->value()*scale);
updateSettings();
}
void ModelEdit::phaseFadeOut_editingFinished()
{
QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox*>(sender());
int phase = spinBox->objectName().mid(5,1).toInt();
int scale=GetEepromInterface()->getCapability(SlowScale);
g_model.phaseData[phase].fadeOut = round(spinBox->value()*scale);
updateSettings();
}
void ModelEdit::on_timer1ModeCB_currentIndexChanged(int index)
{
g_model.timers[0].mode = TimerMode(ui->timer1ModeCB->itemData(index).toInt());
updateSettings();
}
void ModelEdit::on_timer1DirCB_currentIndexChanged(int index)
{
g_model.timers[0].dir = index;
updateSettings();
}
void ModelEdit::on_timer1ValTE_editingFinished()
{
g_model.timers[0].val = ui->timer1ValTE->time().minute()*60 + ui->timer1ValTE->time().second();
updateSettings();
}
void ModelEdit::on_timer1ModeBCB_currentIndexChanged(int index)
{
g_model.timers[0].modeB = ui->timer1ModeBCB->itemData(index).toInt();
updateSettings();
}
void ModelEdit::on_timer2ModeCB_currentIndexChanged(int index)
{
g_model.timers[1].mode = TimerMode(ui->timer2ModeCB->itemData(index).toInt());
updateSettings();
}
void ModelEdit::on_timer2DirCB_currentIndexChanged(int index)
{
g_model.timers[1].dir = index;
updateSettings();
}
void ModelEdit::on_timer2ValTE_editingFinished()
{
g_model.timers[1].val = ui->timer2ValTE->time().minute()*60 + ui->timer2ValTE->time().second();
updateSettings();
}
void ModelEdit::on_timer2ModeBCB_currentIndexChanged(int index)
{
g_model.timers[1].modeB = ui->timer2ModeBCB->itemData(index).toInt();
updateSettings();
}
void ModelEdit::on_trimIncCB_currentIndexChanged(int index)
{
g_model.trimInc = index;
updateSettings();
}
void ModelEdit::on_ttraceCB_currentIndexChanged(int index)
{
g_model.thrTraceSrc = index;
updateSettings();
}
void ModelEdit::on_pulsePolCB_currentIndexChanged(int index)
{
g_model.moduleData[0].ppmPulsePol = index;
updateSettings();
}
void ModelEdit::on_pulsePolCB_2_currentIndexChanged(int index)
{
g_model.moduleData[1].ppmPulsePol = index;
updateSettings();
}
void ModelEdit::on_pulsePolCB_3_currentIndexChanged(int index)
{
g_model.moduleData[2].ppmPulsePol = index;
updateSettings();
}
void ModelEdit::on_protocolCB_currentIndexChanged(int index)
{
if (!protocolEditLock) {
protocolEditLock=true;
g_model.moduleData[0].protocol=(Protocol)ui->protocolCB->itemData(index).toInt();
int protocol=g_model.moduleData[0].protocol;
// g_model.protocol = (Protocol)index;
if (protocol==PXX_XJT_D8 || protocol==OFF) {
ui->FSGB_1->hide();
} else {
ui->fsm1CB->setCurrentIndex(g_model.moduleData[0].failsafeMode);
on_fsm1CB_currentIndexChanged(g_model.moduleData[0].failsafeMode);
ui->FSGB_1->show();
}
updateSettings();
ui->ppmDelaySB->setEnabled(!protocol);
ui->numChannelsSB->setEnabled(!protocol);
if (GetEepromInterface()->getCapability(HasPPMStart)) {
ui->numChannelsSB->setSingleStep(1);
} else {
ui->numChannelsSB->setSingleStep(2);
}
switch (protocol) {
case OFF:
ui->label_PPM->hide();
ui->ppmDelaySB->hide();
ui->label_PPMCH->hide();
ui->label_pulsePol->hide();
ui->pulsePolCB->hide();
ui->numChannelsSB->hide();
ui->label_ppmFrameLength->hide();
ui->ppmFrameLengthDSB->hide();
ui->label_DSM->hide();
ui->DSM_Type->hide();
ui->label_PXX->hide();
ui->pxxRxNum->hide();
ui->label_numChannelsStart->hide();
ui->numChannelsStart->hide();
break;
case PXX_XJT_X16:
case PXX_XJT_D8:
case PXX_XJT_LR12:
case PXX_DJT:
ui->label_PPM->hide();
ui->ppmDelaySB->hide();
ui->ppmDelaySB->setEnabled(false);
ui->label_PPMCH->show();
ui->label_pulsePol->hide();
ui->pulsePolCB->hide();
ui->numChannelsSB->show();
ui->numChannelsSB->setEnabled(true);
ui->label_ppmFrameLength->hide();
ui->ppmFrameLengthDSB->hide();
ui->ppmFrameLengthDSB->setEnabled(false);
ui->label_DSM->hide();
ui->DSM_Type->hide();
ui->DSM_Type->setEnabled(false);
ui->label_PXX->show();
ui->pxxRxNum->setMinimum(0);
ui->pxxRxNum->show();
ui->pxxRxNum->setEnabled(true);
ui->pxxRxNum->setValue((g_model.moduleData[0].channelsCount-8)/2+1);
ui->label_numChannelsStart->show();
ui->numChannelsStart->show();
ui->numChannelsStart->setValue(g_model.moduleData[0].channelsStart+1);
ui->numChannelsSB->setMinimum(g_model.moduleData[0].channelsStart+4);
ui->numChannelsSB->setValue(g_model.moduleData[0].channelsStart+g_model.moduleData[0].channelsCount);
break;
case LP45:
case DSM2:
case DSMX:
ui->label_pulsePol->hide();
ui->pulsePolCB->hide();
ui->label_PPM->hide();
ui->ppmDelaySB->hide();
ui->ppmDelaySB->setEnabled(false);
ui->label_PPMCH->hide();
ui->label_numChannelsStart->hide();
ui->numChannelsStart->hide();
ui->numChannelsSB->hide();
ui->numChannelsSB->setEnabled(false);
ui->label_ppmFrameLength->hide();
ui->ppmFrameLengthDSB->hide();
ui->ppmFrameLengthDSB->setEnabled(false);
if (!GetEepromInterface()->getCapability(DSM2Indexes)) {
ui->label_PXX->hide();
ui->pxxRxNum->hide();
ui->pxxRxNum->setEnabled(false);
}
else {
ui->pxxRxNum->setMinimum(0);
ui->pxxRxNum->setValue(g_model.modelId);
ui->label_PXX->show();
ui->pxxRxNum->show();
ui->pxxRxNum->setEnabled(true);
}
ui->DSM_Type->setEnabled(false);
ui->label_DSM->hide();
ui->DSM_Type->hide();
break;
default:
if (GetEepromInterface()->getCapability(HasPPMStart)) {
ui->label_numChannelsStart->show();
ui->numChannelsStart->show();
}
else {
ui->label_numChannelsStart->hide();
ui->numChannelsStart->hide();
}
ui->numChannelsStart->setValue(g_model.moduleData[0].channelsStart+1);
ui->numChannelsSB->setMinimum(g_model.moduleData[0].channelsStart+4);
ui->numChannelsSB->setValue(g_model.moduleData[0].channelsStart + g_model.moduleData[0].channelsCount);
ui->label_pulsePol->show();
ui->pulsePolCB->show();
ui->label_DSM->hide();
ui->DSM_Type->hide();
ui->DSM_Type->setEnabled(false);
ui->label_PXX->hide();
ui->pxxRxNum->hide();
ui->pxxRxNum->setEnabled(false);
ui->label_PPM->show();
ui->ppmDelaySB->show();
ui->ppmDelaySB->setEnabled(true);
ui->label_PPMCH->show();
ui->numChannelsSB->show();
ui->numChannelsSB->setEnabled(true);
ui->ppmFrameLengthDSB->setEnabled(true);
ui->ppmFrameLengthDSB->setMinimum(g_model.moduleData[0].channelsCount*(g_model.extendedLimits ? 2.250 :2)+3.5);
if (GetEepromInterface()->getCapability(PPMExtCtrl)) {
ui->ppmFrameLengthDSB->show();
ui->label_ppmFrameLength->show();
}
break;
}
protocolEditLock=false;
}
}
void ModelEdit::on_protocolCB_2_currentIndexChanged(int index)
{
if (!protocol2EditLock) {
protocol2EditLock=true;
g_model.moduleData[1].protocol=(Protocol)ui->protocolCB_2->itemData(index).toInt();
int protocol=g_model.moduleData[1].protocol;
if (protocol==PXX_XJT_X16 || protocol==PXX_XJT_LR12) {
ui->FSGB_2->show();
ui->fsm2CB->setCurrentIndex(g_model.moduleData[1].failsafeMode);
on_fsm2CB_currentIndexChanged(g_model.moduleData[1].failsafeMode);
} else {
ui->FSGB_2->hide();
}
// g_model.protocol = (Protocol)index;
updateSettings();
ui->ppmDelaySB_2->setEnabled(!protocol);
ui->numChannelsSB_2->setEnabled(!protocol);
if (GetEepromInterface()->getCapability(HasPPMStart)) {
ui->numChannelsSB_2->setSingleStep(1);
} else {
ui->numChannelsSB_2->setSingleStep(2);
}
switch (protocol) {
case OFF:
ui->label_PPM_2->hide();
ui->ppmDelaySB_2->hide();
ui->label_PPMCH_2->hide();
ui->label_pulsePol_2->hide();
ui->pulsePolCB_2->hide();
ui->numChannelsSB_2->hide();
ui->label_ppmFrameLength_2->hide();
ui->ppmFrameLengthDSB_2->hide();
ui->label_DSM_2->hide();
ui->DSM_Type_2->hide();
ui->label_PXX_2->hide();
ui->pxxRxNum_2->hide();
ui->label_numChannelsStart_2->hide();
ui->numChannelsStart_2->hide();
break;
case PXX_XJT_X16:
case PXX_XJT_D8:
case PXX_XJT_LR12:
case PXX_DJT:
ui->label_PPM_2->hide();
ui->ppmDelaySB_2->hide();
ui->ppmDelaySB_2->setEnabled(false);
ui->label_PPMCH_2->show();
ui->label_pulsePol_2->hide();
ui->pulsePolCB_2->hide();
ui->numChannelsSB_2->show();
ui->numChannelsSB_2->setEnabled(true);
ui->label_ppmFrameLength_2->hide();
ui->ppmFrameLengthDSB_2->hide();
ui->ppmFrameLengthDSB_2->setEnabled(false);
ui->label_DSM_2->hide();
ui->DSM_Type_2->hide();
ui->DSM_Type_2->setEnabled(false);
ui->label_PXX_2->show();
ui->pxxRxNum_2->setMinimum(0);
ui->pxxRxNum_2->show();
ui->pxxRxNum_2->setEnabled(true);
ui->pxxRxNum_2->setValue(g_model.modelId);
ui->label_numChannelsStart_2->show();
ui->numChannelsStart_2->show();
ui->numChannelsStart_2->setValue(g_model.moduleData[1].channelsStart+1);
ui->numChannelsSB_2->setMinimum(g_model.moduleData[1].channelsStart+4);
ui->numChannelsSB_2->setValue(g_model.moduleData[1].channelsStart+g_model.moduleData[1].channelsCount);
break;
case LP45:
case DSM2:
case DSMX:
ui->label_pulsePol_2->hide();
ui->pulsePolCB_2->hide();
ui->label_PPM_2->hide();
ui->ppmDelaySB_2->hide();
ui->ppmDelaySB_2->setEnabled(false);
ui->label_PPMCH_2->hide();
ui->numChannelsSB_2->hide();
ui->numChannelsSB_2->setEnabled(false);
ui->label_ppmFrameLength_2->hide();
ui->ppmFrameLengthDSB_2->hide();
ui->ppmFrameLengthDSB_2->setEnabled(false);
if (!GetEepromInterface()->getCapability(DSM2Indexes)) {
ui->label_PXX_2->hide();
ui->pxxRxNum_2->hide();
ui->pxxRxNum_2->setEnabled(false);
} else {
ui->pxxRxNum_2->setMinimum(0);
ui->pxxRxNum_2->setValue(g_model.modelId);
ui->label_PXX_2->show();
ui->pxxRxNum_2->show();
ui->pxxRxNum_2->setEnabled(true);
}
ui->DSM_Type_2->setEnabled(false);
ui->label_DSM_2->hide();
ui->DSM_Type_2->hide();
break;
default:
if (GetEepromInterface()->getCapability(HasPPMStart)) {
ui->label_numChannelsStart_2->show();
ui->numChannelsStart_2->show();
} else {
ui->label_numChannelsStart_2->hide();
ui->numChannelsStart_2->hide();
}
ui->numChannelsStart_2->setValue(g_model.moduleData[1].channelsStart+1);
ui->numChannelsSB_2->setMinimum(g_model.moduleData[1].channelsStart+4);
ui->numChannelsSB_2->setValue(g_model.moduleData[1].channelsStart+g_model.moduleData[1].channelsCount);
ui->label_pulsePol_2->show();
ui->pulsePolCB_2->show();
ui->pulsePolCB_2->setCurrentIndex(g_model.moduleData[1].ppmPulsePol);
ui->label_DSM_2->hide();
ui->DSM_Type_2->hide();
ui->DSM_Type_2->setEnabled(false);
ui->label_PXX_2->hide();
ui->pxxRxNum_2->hide();
ui->pxxRxNum_2->setEnabled(false);
ui->label_PPM_2->show();
ui->ppmDelaySB_2->show();
ui->ppmDelaySB_2->setEnabled(true);
ui->ppmDelaySB_2->setValue(g_model.moduleData[1].ppmDelay);
ui->label_PPMCH_2->show();
ui->numChannelsSB_2->show();
ui->numChannelsSB_2->setEnabled(true);
ui->ppmFrameLengthDSB_2->setEnabled(true);
ui->ppmFrameLengthDSB_2->setMinimum(g_model.moduleData[1].channelsCount*(g_model.extendedLimits ? 2.250 :2)+3.5);
if (GetEepromInterface()->getCapability(PPMExtCtrl)) {
ui->ppmFrameLengthDSB_2->show();
ui->label_ppmFrameLength_2->show();
ui->ppmFrameLengthDSB_2->setValue(g_model.moduleData[1].ppmFrameLength/2.0+22.5);
}
break;
}
protocol2EditLock=false;
}
}
void ModelEdit::on_protocolCB_3_currentIndexChanged(int index)
{
if (!trainerEditLock) {
trainerEditLock=true;
g_model.moduleData[2].protocol=ui->protocolCB_3->currentIndex();
g_model.trainerMode=ui->protocolCB_3->currentIndex();
updateSettings();
switch (index) {
case 0:
ui->label_PPM_3->hide();
ui->ppmDelaySB_3->hide();
ui->label_PPMCH_3->hide();
ui->label_pulsePol_3->hide();
ui->pulsePolCB_3->hide();
ui->numChannelsSB_3->hide();
ui->label_ppmFrameLength_3->hide();
ui->ppmFrameLengthDSB_3->hide();
ui->label_numChannelsStart_3->hide();
ui->numChannelsStart_3->hide();
break;
default:
ui->label_PPM_3->show();
ui->ppmDelaySB_3->show();
ui->label_PPMCH_3->show();
ui->label_pulsePol_3->show();
ui->pulsePolCB_3->show();
ui->numChannelsSB_3->show();
ui->label_ppmFrameLength_3->show();
ui->ppmFrameLengthDSB_3->show();
ui->label_numChannelsStart_3->show();
ui->numChannelsStart_3->show();
ui->numChannelsStart_3->setValue(g_model.moduleData[2].channelsStart+1);
ui->numChannelsSB_3->setMinimum(g_model.moduleData[2].channelsStart+4);
ui->numChannelsSB_3->setValue(g_model.moduleData[2].channelsStart+g_model.moduleData[2].channelsCount);
ui->pulsePolCB_3->setCurrentIndex(g_model.moduleData[2].ppmPulsePol);
ui->ppmDelaySB_3->setValue(g_model.moduleData[2].ppmDelay);
ui->ppmFrameLengthDSB_3->setMinimum(g_model.moduleData[2].channelsCount*(g_model.extendedLimits ? 2.250 :2)+3.5);
if (GetEepromInterface()->getCapability(PPMExtCtrl)) {
ui->ppmFrameLengthDSB_3->show();
ui->label_ppmFrameLength_3->show();
ui->ppmFrameLengthDSB_3->setValue(g_model.moduleData[2].ppmFrameLength/2.0+22.5);
}
break;
}
trainerEditLock=false;
}
}
void ModelEdit::on_numChannelsSB_editingFinished()
{
// TODO only accept valid values
g_model.moduleData[0].channelsCount = 1+ui->numChannelsSB->value()-ui->numChannelsStart->value();
ui->ppmFrameLengthDSB->setMinimum(g_model.moduleData[0].channelsCount*(g_model.extendedLimits ? 2.250 :2)+3.5);
updateSettings();
}
void ModelEdit::on_numChannelsSB_2_editingFinished()
{
// TODO only accept valid values
g_model.moduleData[1].channelsCount = 1+ui->numChannelsSB_2->value()-ui->numChannelsStart_2->value();
ui->ppmFrameLengthDSB_2->setMinimum(g_model.moduleData[1].channelsCount*(g_model.extendedLimits ? 2.250 :2.0)+3.5);
updateSettings();
}
void ModelEdit::on_numChannelsSB_3_editingFinished()
{
// TODO only accept valid values
g_model.moduleData[2].channelsCount = 1+ui->numChannelsSB_3->value()-ui->numChannelsStart_3->value();
ui->ppmFrameLengthDSB_3->setMinimum(g_model.moduleData[2].channelsCount*(g_model.extendedLimits ? 2.250 :2)+3.5);
updateSettings();
}
void ModelEdit::on_numChannelsStart_editingFinished()
{
// TODO only accept valid values
g_model.moduleData[0].channelsStart = ui->numChannelsStart->value()-1;
ui->numChannelsSB->setMinimum(g_model.moduleData[0].channelsStart+4);
ui->numChannelsSB->setValue(g_model.moduleData[0].channelsStart+g_model.moduleData[0].channelsCount);
updateSettings();
}
void ModelEdit::on_numChannelsStart_2_editingFinished()
{
// TODO only accept valid values
g_model.moduleData[1].channelsStart = ui->numChannelsStart_2->value()-1;
ui->numChannelsSB_2->setMinimum(g_model.moduleData[1].channelsStart+4);
ui->numChannelsSB_2->setValue(g_model.moduleData[1].channelsStart+g_model.moduleData[1].channelsCount);
updateSettings();
}
void ModelEdit::on_numChannelsStart_3_editingFinished()
{
// TODO only accept valid values
g_model.moduleData[2].channelsStart = ui->numChannelsStart_3->value()-1;
ui->numChannelsSB_3->setMinimum(g_model.moduleData[2].channelsStart+4);
ui->numChannelsSB_3->setValue(g_model.moduleData[2].channelsStart+g_model.moduleData[2].channelsCount);
updateSettings();
}
void ModelEdit::on_ppmDelaySB_editingFinished()
{
if(protocolEditLock) return;
// TODO only accept valid values
g_model.moduleData[0].ppmDelay = ui->ppmDelaySB->value();
updateSettings();
}
void ModelEdit::on_ppmDelaySB_2_editingFinished()
{
if(protocol2EditLock) return;
// TODO only accept valid values
g_model.moduleData[1].ppmDelay = ui->ppmDelaySB_2->value();
updateSettings();
}
void ModelEdit::on_ppmDelaySB_3_editingFinished()
{
if(trainerEditLock) return;
// TODO only accept valid values
g_model.moduleData[2].ppmDelay = ui->ppmDelaySB_3->value();
updateSettings();
}
void ModelEdit::on_DSM_Type_currentIndexChanged(int index)
{
if(protocolEditLock) return;
// g_model.moduleData[0].channelsCount = (index*2)+8;
updateSettings();
}
void ModelEdit::on_DSM_Type_2_currentIndexChanged(int index)
{
if(protocol2EditLock) return;
// g_model.moduleData[1].channelsCount = (index*2)+8;
updateSettings();
}
void ModelEdit::on_pxxRxNum_editingFinished()
{
if(protocolEditLock)
return;
if (!GetEepromInterface()->getCapability(DSM2Indexes)) {
// g_model.moduleData[0].channelsCount = (ui->pxxRxNum->value()-1)*2+8;
} else {
g_model.modelId = ui->pxxRxNum->value();
}
updateSettings();
}
void ModelEdit::on_pxxRxNum_2_editingFinished()
{
if(protocol2EditLock)
return;
/* if (!GetEepromInterface()->getCapability(DSM2Indexes)) {
g_model.moduleData[1].channelsCount = (ui->pxxRxNum_2->value()-1)*2+8;
} */
updateSettings();
}
void ModelEdit::on_ppmFrameLengthDSB_editingFinished()
{
g_model.moduleData[0].ppmFrameLength = (ui->ppmFrameLengthDSB->value()-22.5)/0.5;
updateSettings();
}
void ModelEdit::on_ppmFrameLengthDSB_2_editingFinished()
{
g_model.moduleData[1].ppmFrameLength = (ui->ppmFrameLengthDSB_2->value()-22.5)/0.5;
updateSettings();
}
void ModelEdit::on_ppmFrameLengthDSB_3_editingFinished()
{
g_model.moduleData[2].ppmFrameLength = (ui->ppmFrameLengthDSB_3->value()-22.5)/0.5;
updateSettings();
}
void ModelEdit::on_fsm1CB_currentIndexChanged(int index)
{
QSpinBox * fssb[] = { ui->fsm1SB_1, ui->fsm1SB_2,ui->fsm1SB_3,ui->fsm1SB_4,ui->fsm1SB_5,ui->fsm1SB_6,ui->fsm1SB_7,ui->fsm1SB_8,
ui->fsm1SB_9, ui->fsm1SB_10,ui->fsm1SB_11,ui->fsm1SB_12,ui->fsm1SB_13,ui->fsm1SB_14,ui->fsm1SB_15,ui->fsm1SB_16, NULL };
QSlider * fssld[] = { ui->fsm1SL_1, ui->fsm1SL_2,ui->fsm1SL_3,ui->fsm1SL_4,ui->fsm1SL_5,ui->fsm1SL_6,ui->fsm1SL_7,ui->fsm1SL_8,
ui->fsm1SL_9, ui->fsm1SL_10,ui->fsm1SL_11,ui->fsm1SL_12,ui->fsm1SL_13,ui->fsm1SL_14,ui->fsm1SL_15,ui->fsm1SL_16, NULL };
g_model.moduleData[0].failsafeMode=index;
for (int i=0; fssb[i]; i++) {
if (index==1) {
fssb[i]->setEnabled(true);
fssld[i]->setEnabled(true);
} else {
fssb[i]->setDisabled(true);
fssld[i]->setDisabled(true);
}
}
updateSettings();
}
void ModelEdit::on_fsm2CB_currentIndexChanged(int index)
{
QSpinBox * fssb[] = { ui->fsm2SB_1, ui->fsm2SB_2,ui->fsm2SB_3,ui->fsm2SB_4,ui->fsm2SB_5,ui->fsm2SB_6,ui->fsm2SB_7,ui->fsm2SB_8,
ui->fsm2SB_9, ui->fsm2SB_10,ui->fsm2SB_11,ui->fsm2SB_12,ui->fsm2SB_13,ui->fsm2SB_14,ui->fsm2SB_15,ui->fsm2SB_16, NULL };
QSlider * fssld[] = { ui->fsm2SL_1, ui->fsm2SL_2,ui->fsm2SL_3,ui->fsm2SL_4,ui->fsm2SL_5,ui->fsm2SL_6,ui->fsm2SL_7,ui->fsm2SL_8,
ui->fsm2SL_9, ui->fsm2SL_10,ui->fsm2SL_11,ui->fsm2SL_12,ui->fsm2SL_13,ui->fsm2SL_14,ui->fsm2SL_15,ui->fsm2SL_16, NULL };
g_model.moduleData[1].failsafeMode=index;
for (int i=0; fssb[i]; i++) {
if (index==1) {
fssb[i]->setEnabled(true);
fssld[i]->setEnabled(true);
} else {
fssb[i]->setDisabled(true);
fssld[i]->setDisabled(true);
}
}
updateSettings();
}
void ModelEdit::on_instantTrim_CB_currentIndexChanged(int index)
{
if(switchEditLock) return;
bool found=false;
for (int i=0; i< C9X_MAX_CUSTOM_FUNCTIONS; i++) {
if (g_model.funcSw[i].func==FuncInstantTrim) {
g_model.funcSw[i].swtch = RawSwitch(ui->instantTrim_CB->itemData(ui->instantTrim_CB->currentIndex()).toInt());
found=true;
}
}
if (found==false) {
for (int i=0; i< C9X_MAX_CUSTOM_FUNCTIONS; i++) {
if (g_model.funcSw[i].swtch==RawSwitch()) {
g_model.funcSw[i].swtch = RawSwitch(ui->instantTrim_CB->itemData(ui->instantTrim_CB->currentIndex()).toInt());
g_model.funcSw[i].func = FuncInstantTrim;
break;
}
}
}
updateSettings();
}
void ModelEdit::on_a1UnitCB_currentIndexChanged(int index) {
float a1ratio;
g_model.frsky.channels[0].type=index;
switch (index) {
case 0:
case 1:
case 2:
ui->a1RatioSB->setDecimals(1);
ui->a1RatioSB->setMaximum(25.5*GetEepromInterface()->getCapability(TelemetryMaxMultiplier));
a1ratio=(g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier)/10.0;
break;
default:
ui->a1RatioSB->setDecimals(0);
ui->a1RatioSB->setMaximum(255*GetEepromInterface()->getCapability(TelemetryMaxMultiplier));
a1ratio=(g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier);
break;
}
ui->a1RatioSB->setValue(a1ratio);
updateA1Fields();
updateSettings();
}
void ModelEdit::on_a1RatioSB_valueChanged()
{
if (telemetryLock) return;
if (g_model.frsky.channels[0].type==0 || g_model.frsky.channels[0].type==1 || g_model.frsky.channels[0].type==2) {
g_model.frsky.channels[0].multiplier = findmult(ui->a1RatioSB->value(), 25.5);
float singlestep =(1<<g_model.frsky.channels[0].multiplier)/10.0;
telemetryLock=true;
ui->a1RatioSB->setSingleStep(singlestep);
ui->a1RatioSB->setValue(round(ui->a1RatioSB->value()/singlestep)*singlestep);
telemetryLock=false;
} else {
g_model.frsky.channels[0].multiplier = findmult(ui->a1RatioSB->value(), 255);
float singlestep =(1<<g_model.frsky.channels[0].multiplier);
telemetryLock=true;
ui->a1RatioSB->setSingleStep(singlestep);
ui->a1RatioSB->setValue(round(ui->a1RatioSB->value()/singlestep)*singlestep);
telemetryLock=false;
}
}
void ModelEdit::on_a1RatioSB_editingFinished()
{
float a1ratio, a1calib, a11value,a12value;
if (telemetryLock) return;
if (g_model.frsky.channels[0].type==0 || g_model.frsky.channels[0].type==1 || g_model.frsky.channels[0].type==2) {
g_model.frsky.channels[0].multiplier = findmult(ui->a1RatioSB->value(), 25.5);
ui->a1CalibSB->setSingleStep((1<<g_model.frsky.channels[0].multiplier)/10.0);
ui->a11ValueSB->setSingleStep((1<<g_model.frsky.channels[0].multiplier)/10.0);
ui->a12ValueSB->setSingleStep((1<<g_model.frsky.channels[0].multiplier)/10.0);
g_model.frsky.channels[0].ratio = ((int)(round(ui->a1RatioSB->value()*10))/(1 <<g_model.frsky.channels[0].multiplier));
} else {
g_model.frsky.channels[0].multiplier = findmult(ui->a1RatioSB->value(), 255);
ui->a1CalibSB->setSingleStep(1<<g_model.frsky.channels[0].multiplier);
ui->a11ValueSB->setSingleStep(1<<g_model.frsky.channels[0].multiplier);
ui->a12ValueSB->setSingleStep(1<<g_model.frsky.channels[0].multiplier);
g_model.frsky.channels[0].ratio = (ui->a1RatioSB->value()/(1 << g_model.frsky.channels[0].multiplier));
}
ui->a1CalibSB->setMaximum((ui->a1RatioSB->value()*127)/255);
ui->a1CalibSB->setMinimum((ui->a1RatioSB->value()*-128)/255);
ui->a11ValueSB->setMaximum(ui->a1RatioSB->value());
ui->a12ValueSB->setMaximum(ui->a1RatioSB->value());
repaint();
a1ratio=g_model.frsky.channels[0].ratio * (1 << g_model.frsky.channels[0].multiplier);
a1calib=ui->a1CalibSB->value();
a11value=ui->a11ValueSB->value();
a12value=ui->a12ValueSB->value();
if (g_model.frsky.channels[0].type==0) {
a1calib*=10;
a11value*=10;
a12value*=10;
}
if (a1calib>0) {
if (a1calib>((a1ratio*127)/255)) {
g_model.frsky.channels[0].offset=127;
} else {
g_model.frsky.channels[0].offset=round(a1calib*255/a1ratio);
}
}
if (a1calib<0) {
if (a1calib<((a1ratio*-128)/255)) {
g_model.frsky.channels[0].offset=-128;
} else {
g_model.frsky.channels[0].offset=round(a1calib*255/a1ratio);
}
}
g_model.frsky.channels[0].alarms[0].value=round((a11value*255-g_model.frsky.channels[0].offset*(g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier))/(g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier));
g_model.frsky.channels[0].alarms[1].value=round((a12value*255-g_model.frsky.channels[0].offset*(g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier))/(g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier));
updateA1Fields();
telBarUpdate();
updateSettings();
}
void ModelEdit::on_a1CalibSB_editingFinished()
{
float a1ratio,a1calib,a11value,a12value;
if (g_model.frsky.channels[0].type==0 || g_model.frsky.channels[0].type==1 || g_model.frsky.channels[0].type==2) {
a1ratio=(g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier)/10.0;
} else {
a1ratio=g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier;
}
if (a1ratio!=0) {
g_model.frsky.channels[0].offset = round((255*ui->a1CalibSB->value()/a1ratio));
a1calib=a1ratio*g_model.frsky.channels[0].offset/255.0;
a11value=ui->a11ValueSB->value();
a12value=ui->a12ValueSB->value();
if (a11value<a1calib) {
a11value=a1calib;
} else if (a11value>(a1ratio+a1calib)) {
a11value=a1ratio+a1calib;
}
if (a12value<a1calib) {
a12value=a1calib;
} else if (a12value>(a1ratio+a1calib)) {
a12value=a1ratio+a1calib;
}
g_model.frsky.channels[0].alarms[0].value=round(((a11value-a1calib)*255)/a1ratio);
g_model.frsky.channels[0].alarms[1].value=round(((a12value-a1calib)*255)/a1ratio);
} else {
g_model.frsky.channels[0].offset=0;
g_model.frsky.channels[0].alarms[0].value=0;
g_model.frsky.channels[0].alarms[1].value=0;
}
updateA1Fields();
telBarUpdate();
updateSettings();
}
void ModelEdit::on_a11LevelCB_currentIndexChanged(int index)
{
g_model.frsky.channels[0].alarms[0].level = index;
updateSettings();
}
void ModelEdit::on_frskyUnitsCB_currentIndexChanged(int index)
{
g_model.frsky.imperial=index;
updateSettings();
}
void ModelEdit::on_frskyBladesCB_currentIndexChanged(int index)
{
g_model.frsky.blades=index;
updateSettings();
}
void ModelEdit::on_frskyCurrentCB_currentIndexChanged(int index)
{
g_model.frsky.currentSource=index;
updateSettings();
}
void ModelEdit::on_frskyVoltCB_currentIndexChanged(int index)
{
g_model.frsky.voltsSource=index;
updateSettings();
}
void ModelEdit::on_frskyProtoCB_currentIndexChanged(int index)
{
if (telemetryLock) return;
int bindex[12];
telemetryLock=true;
for (int i=0; i<12; i++) {
bindex[i]=barsCB[i]->currentIndex();
g_model.frsky.usrProto=index;
populateCustomScreenFieldCB(barsCB[i], bindex[i], false, g_model.frsky.usrProto);
}
if (!GetEepromInterface()->getCapability(TelemetryCSFields)) {
ui->groupBox_5->hide();
} else {
for (int screen=0; screen<2;screen++) {
for (int rows=0; rows<4; rows++) {
for (int cols=0; cols<3; cols++) {
int index=screen*12+cols*4+rows;
populateCustomScreenFieldCB(csf[index], g_model.frsky.screens[screen].body.lines[rows].source[cols], (rows<4), g_model.frsky.usrProto);
}
}
}
}
telemetryLock=false;
if (index==0) {
for (int i=0; i<12; i++) {
if (bindex[i]>2) {
barsCB[i]->setCurrentIndex(0);
} else {
barsCB[i]->setCurrentIndex(bindex[i]);
}
}
} else if (index==2) {
for (int i=0; i<12; i++) {
if (bindex[i]>3) {
barsCB[i]->setCurrentIndex(0);
} else {
barsCB[i]->setCurrentIndex(bindex[i]);
}
}
} else {
for (int i=0; i<12; i++) {
barsCB[i]->setCurrentIndex(bindex[i]);
}
}
updateSettings();
}
void ModelEdit::on_a11GreaterCB_currentIndexChanged(int index)
{
g_model.frsky.channels[0].alarms[0].greater = index;
updateSettings();
}
void ModelEdit::on_a11ValueSB_editingFinished()
{
float a1ratio, a1calib, a11value;
a1ratio=g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier;
a1calib=g_model.frsky.channels[0].offset;
a11value=ui->a11ValueSB->value();
if (g_model.frsky.channels[0].type==0) {
a1ratio/=10;
}
if (a11value<((a1calib*a1ratio)/255)) {
g_model.frsky.channels[0].alarms[0].value=0;
} else if (a11value>(a1ratio+(a1calib*a1ratio)/255)) {
g_model.frsky.channels[0].alarms[0].value=255;
} else {
g_model.frsky.channels[0].alarms[0].value = round((a11value-((a1calib*a1ratio)/255))/a1ratio*255);
}
updateA1Fields();
updateSettings();
}
void ModelEdit::on_a12LevelCB_currentIndexChanged(int index)
{
g_model.frsky.channels[0].alarms[1].level = index;
updateSettings();
}
void ModelEdit::on_a12GreaterCB_currentIndexChanged(int index)
{
g_model.frsky.channels[0].alarms[1].greater = index;
updateSettings();
}
void ModelEdit::on_a12ValueSB_editingFinished()
{
float a1ratio, a1calib, a12value;
a1ratio=g_model.frsky.channels[0].ratio<<g_model.frsky.channels[0].multiplier;
a1calib=g_model.frsky.channels[0].offset;
a12value=ui->a12ValueSB->value();
if (g_model.frsky.channels[0].type==0) {
a1ratio/=10;
}
if (a12value<((a1calib*a1ratio)/255)) {
g_model.frsky.channels[0].alarms[1].value=0;
} else if (a12value>(a1ratio+(a1calib*a1ratio)/255)) {
g_model.frsky.channels[0].alarms[1].value=255;
} else {
g_model.frsky.channels[0].alarms[1].value = round((a12value-((a1calib*a1ratio)/255))/a1ratio*255);
}
updateA1Fields();
updateSettings();
}
void ModelEdit::on_a2UnitCB_currentIndexChanged(int index) {
float a2ratio;
g_model.frsky.channels[1].type=index;
switch (index) {
case 0:
case 1:
case 2:
ui->a2RatioSB->setDecimals(1);
ui->a2RatioSB->setMaximum(25.5*GetEepromInterface()->getCapability(TelemetryMaxMultiplier));
a2ratio=(g_model.frsky.channels[1].ratio<<g_model.frsky.channels[1].multiplier)/10.0;
break;
default:
ui->a2RatioSB->setDecimals(0);
ui->a2RatioSB->setMaximum(255*GetEepromInterface()->getCapability(TelemetryMaxMultiplier));
a2ratio=g_model.frsky.channels[1].ratio<<g_model.frsky.channels[1].multiplier;
break;
}
ui->a2RatioSB->setValue(a2ratio);
updateA2Fields();
updateSettings();
}
void ModelEdit::on_a2RatioSB_valueChanged()
{
if (telemetryLock) return;
if (g_model.frsky.channels[1].type==0 || g_model.frsky.channels[1].type==1 || g_model.frsky.channels[1].type==2) {
g_model.frsky.channels[1].multiplier = findmult(ui->a2RatioSB->value(), 25.5);
float singlestep =(1<<g_model.frsky.channels[1].multiplier)/10.0;
telemetryLock=true;
ui->a2RatioSB->setSingleStep(singlestep);
ui->a2RatioSB->setValue(round(ui->a2RatioSB->value()/singlestep)*singlestep);
telemetryLock=false;
} else {
g_model.frsky.channels[1].multiplier = findmult(ui->a2RatioSB->value(), 255);
float singlestep =(1<<g_model.frsky.channels[1].multiplier);
telemetryLock=true;
ui->a2RatioSB->setSingleStep(singlestep);
ui->a2RatioSB->setValue(round(ui->a2RatioSB->value()/singlestep)*singlestep);
telemetryLock=false;
}
}
void ModelEdit::on_a2RatioSB_editingFinished()
{
float a2ratio, a2calib, a21value,a22value;
if (telemetryLock) return;
if (g_model.frsky.channels[1].type==0 || g_model.frsky.channels[1].type==1 || g_model.frsky.channels[1].type==2) {
g_model.frsky.channels[1].multiplier = findmult(ui->a2RatioSB->value(), 25.5);
ui->a2CalibSB->setSingleStep((1<<g_model.frsky.channels[1].multiplier)/10.0);
ui->a21ValueSB->setSingleStep((1<<g_model.frsky.channels[1].multiplier)/10.0);
ui->a22ValueSB->setSingleStep((1<<g_model.frsky.channels[1].multiplier)/10.0);
g_model.frsky.channels[1].ratio = ((round(ui->a2RatioSB->value()*10))/(1 << g_model.frsky.channels[1].multiplier));
} else {
g_model.frsky.channels[1].multiplier = findmult(ui->a2RatioSB->value(), 255);
ui->a2CalibSB->setSingleStep(1<<g_model.frsky.channels[1].multiplier);
ui->a21ValueSB->setSingleStep(1<<g_model.frsky.channels[1].multiplier);
ui->a22ValueSB->setSingleStep(1<<g_model.frsky.channels[1].multiplier);
g_model.frsky.channels[1].ratio = (ui->a2RatioSB->value()/(1 << g_model.frsky.channels[1].multiplier));
}
ui->a2CalibSB->setMaximum((ui->a2RatioSB->value()*127)/255);
ui->a2CalibSB->setMinimum((ui->a2RatioSB->value()*-128)/255);
ui->a21ValueSB->setMaximum(ui->a2RatioSB->value());
ui->a22ValueSB->setMaximum(ui->a2RatioSB->value());
repaint();
a2ratio=g_model.frsky.channels[1].ratio * (1 << g_model.frsky.channels[1].multiplier);
a2calib=ui->a2CalibSB->value();
a21value=ui->a21ValueSB->value();
a22value=ui->a22ValueSB->value();
if (g_model.frsky.channels[1].type==0 || g_model.frsky.channels[1].type==1 || g_model.frsky.channels[1].type==2) {
a2calib*=10;
a21value*=10;
a22value*=10;
}
if (a2calib>0) {
if (a2calib>((a2ratio*127)/255)) {
g_model.frsky.channels[1].offset=127;
} else {
g_model.frsky.channels[1].offset=round(a2calib*255/a2ratio);
}
}
if (a2calib<0) {
if (a2calib<((a2ratio*-128)/255)) {
g_model.frsky.channels[1].offset=-128;
} else {
g_model.frsky.channels[1].offset=round(a2calib*255/a2ratio);
}
}
g_model.frsky.channels[1].alarms[0].value=round((a21value*255-g_model.frsky.channels[1].offset*(g_model.frsky.channels[1].ratio<<g_model.frsky.channels[1].multiplier))/(g_model.frsky.channels[1].ratio<<g_model.frsky.channels[1].multiplier));
g_model.frsky.channels[1].alarms[1].value=round((a22value*255-g_model.frsky.channels[1].offset*(g_model.frsky.channels[1].ratio<<g_model.frsky.channels[1].multiplier))/(g_model.frsky.channels[1].ratio<<g_model.frsky.channels[1].multiplier));
updateA2Fields();
telBarUpdate();
updateSettings();
}
void ModelEdit::on_a2CalibSB_editingFinished()
{
float a2ratio,a2calib,a21value,a22value;
if (g_model.frsky.channels[1].type==0 || g_model.frsky.channels[1].type==1 || g_model.frsky.channels[1].type==2) {
a2ratio=(g_model.frsky.channels[1].ratio<<g_model.frsky.channels[1].multiplier)/10.0;
} else {
a2ratio=g_model.frsky.channels[1].ratio<<g_model.frsky.channels[1].multiplier;
}
if (a2ratio!=0) {
g_model.frsky.channels[1].offset = round((255*ui->a2CalibSB->value()/a2ratio));
a2calib=a2ratio*g_model.frsky.channels[1].offset/255.0;
a21value=ui->a21ValueSB->value();
a22value=ui->a22ValueSB->value();
if (a21value<a2calib) {
a21value=a2calib;
} else if (a21value>(a2ratio+a2calib)) {
a21value=a2ratio+a2calib;
}
if (a22value<a2calib) {
a22value=a2calib;
} else if (a22value>(a2ratio+a2calib)) {
a22value=a2ratio+a2calib;
}
g_model.frsky.channels[1].alarms[0].value=round(((a21value-a2calib)*255)/a2ratio);
g_model.frsky.channels[1].alarms[1].value=round(((a22value-a2calib)*255)/a2ratio);
} else {
g_model.frsky.channels[1].offset=0;
g_model.frsky.channels[1].alarms[0].value=0;
g_model.frsky.channels[1].alarms[1].value=0;
}
updateA2Fields();
telBarUpdate();
updateSettings();
}
void ModelEdit::on_a21LevelCB_currentIndexChanged(int index)
{
g_model.frsky.channels[1].alarms[0].level = index;
updateSettings();
}
void ModelEdit::on_a21GreaterCB_currentIndexChanged(int index)
{
g_model.frsky.channels[1].alarms[0].greater = index;
updateSettings();
}
void ModelEdit::on_a21ValueSB_editingFinished()
{
float a2ratio, a2calib, a21value;
a2ratio=g_model.frsky.channels[1].ratio<<g_model.frsky.channels[1].multiplier;
a2calib=g_model.frsky.channels[1].offset;
a21value=ui->a21ValueSB->value();
if (g_model.frsky.channels[1].type==0) {
a2ratio/=10;
}
if (a21value<((a2calib*a2ratio)/255)) {
g_model.frsky.channels[1].alarms[0].value=0;
} else if (a21value>(a2ratio+(a2calib*a2ratio)/255)) {
g_model.frsky.channels[1].alarms[0].value=255;
} else {
g_model.frsky.channels[1].alarms[0].value = round((a21value-((a2calib*a2ratio)/255))/a2ratio*255);
}
updateA2Fields();
updateSettings();
}
void ModelEdit::on_a22LevelCB_currentIndexChanged(int index)
{
g_model.frsky.channels[1].alarms[1].level = index;
updateSettings();
}
void ModelEdit::on_a22GreaterCB_currentIndexChanged(int index)
{
g_model.frsky.channels[1].alarms[1].greater = index;
updateSettings();
}
void ModelEdit::on_a22ValueSB_editingFinished()
{
float a2ratio, a2calib, a22value;
a2ratio=g_model.frsky.channels[1].ratio<<g_model.frsky.channels[1].multiplier;
a2calib=g_model.frsky.channels[1].offset;
a22value=ui->a22ValueSB->value();
if (g_model.frsky.channels[1].type==0) {
a2ratio/=10;
}
if (a22value<((a2calib*a2ratio)/255)) {
g_model.frsky.channels[1].alarms[1].value=0;
} else if (a22value>(a2ratio+(a2calib*a2ratio)/255)) {
g_model.frsky.channels[1].alarms[1].value=255;
} else {
g_model.frsky.channels[1].alarms[1].value = round((a22value-((a2calib*a2ratio)/255))/a2ratio*255);
}
updateA2Fields();
updateSettings();
}
void ModelEdit::on_rssiAlarm1CB_currentIndexChanged(int index) {
if (telemetryLock) return;
g_model.frsky.rssiAlarms[0].level=index;
updateSettings();
}
void ModelEdit::on_rssiAlarm2CB_currentIndexChanged(int index) {
if (telemetryLock) return;
g_model.frsky.rssiAlarms[1].level=index;
updateSettings();
}
void ModelEdit::on_rssiAlarm1SB_editingFinished() {
if (telemetryLock) return;
g_model.frsky.rssiAlarms[0].value=(ui->rssiAlarm1SB->value());
updateSettings();
}
void ModelEdit::on_rssiAlarm2SB_editingFinished() {
if (telemetryLock) return;
g_model.frsky.rssiAlarms[1].value=(ui->rssiAlarm2SB->value());
updateSettings();
}
void ModelEdit::on_AltitudeGPS_ChkB_toggled(bool checked)
{
if (telemetryLock) return;
g_model.frsky.FrSkyGpsAlt = checked;
updateSettings();
//AltitudeGPS_CB
}
void ModelEdit::on_showNames_Ckb_toggled(bool checked)
{
tabMixes();
}
void ModelEdit::on_varioSourceCB_currentIndexChanged(int index)
{
if (telemetryLock) return;
g_model.frsky.varioSource = index;
updateSettings();
}
void ModelEdit::on_varioLimitMin_DSB_editingFinished()
{
if (telemetryLock) return;
g_model.frsky.varioMin= round(ui->varioLimitMin_DSB->value()+10);
updateSettings();
}
void ModelEdit::on_varioLimitMax_DSB_editingFinished()
{
if (telemetryLock) return;
g_model.frsky.varioMax= round(ui->varioLimitMax_DSB->value()-10);
updateSettings();
}
void ModelEdit::on_varioLimitCenterMin_DSB_editingFinished()
{
if (telemetryLock) return;
if (ui->varioLimitCenterMin_DSB->value()>ui->varioLimitCenterMax_DSB->value()) {
ui->varioLimitCenterMax_DSB->setValue(ui->varioLimitCenterMin_DSB->value());
}
g_model.frsky.varioCenterMin= round((ui->varioLimitCenterMin_DSB->value()+0.5)*10);
updateSettings();
}
void ModelEdit::on_varioLimitMinOff_ChkB_toggled(bool checked)
{
if (telemetryLock) return;
g_model.frsky.varioCenterMin = -16;
if (!checked) {
telemetryLock=true;
ui->varioLimitCenterMin_DSB->setValue(-2.0);
ui->varioLimitCenterMin_DSB->setEnabled(true);
telemetryLock=false;
} else {
ui->varioLimitCenterMin_DSB->setValue(-2.0);
ui->varioLimitCenterMin_DSB->setDisabled(true);
}
updateSettings();
}
void ModelEdit::on_varioLimitCenterMax_DSB_editingFinished()
{
if (telemetryLock) return;
if (ui->varioLimitCenterMin_DSB->value()>ui->varioLimitCenterMax_DSB->value()) {
ui->varioLimitCenterMax_DSB->setValue(ui->varioLimitCenterMin_DSB->value());
}
g_model.frsky.varioCenterMax= round((ui->varioLimitCenterMax_DSB->value()-0.5)*10);
updateSettings();
}
void ModelEdit::telBarUpdate()
{
int index;
telemetryLock=true;
for (int i=0; i<12; i++) {
int screen=i/4;
index=barsCB[i]->currentIndex();
if (index==TELEMETRY_SOURCE_A1 || index==TELEMETRY_SOURCE_A1 || index==TELEMETRY_SOURCE_A1_MIN || index==TELEMETRY_SOURCE_A2_MIN) {
minSB[i]->setMinimum(getBarValue(index, 0, &g_model.frsky));
minSB[i]->setMaximum(getBarValue(index, 255, &g_model.frsky));
minSB[i]->setSingleStep(getBarStep(index));
maxSB[i]->setMinimum(getBarValue(index, 0, &g_model.frsky));
maxSB[i]->setMaximum(getBarValue(index, 255, &g_model.frsky));
maxSB[i]->setSingleStep(getBarStep(index));
minSB[i]->setValue(getBarValue(index, g_model.frsky.screens[screen].body.bars[i%4].barMin, &g_model.frsky));
maxSB[i]->setValue(getBarValue(index, 255-g_model.frsky.screens[screen].body.bars[i%4].barMax, &g_model.frsky));
}
}
telemetryLock=false;
}
void ModelEdit::ScreenTypeCBcurrentIndexChanged(int index)
{
if (telemetryLock) return;
QComboBox *comboBox = qobject_cast<QComboBox*>(sender());
int screen = comboBox->objectName().right(1).toInt() -1;
telemetryLock=true;
g_model.frsky.screens[screen].type=index;
for (int i=0; i<3; i++) {
bool isNum = (g_model.frsky.screens[i].type==0);
barsGB[i]->setVisible(!isNum);
numsGB[i]->setVisible(isNum);
}
telemetryLock=false;
updateSettings();
}
void ModelEdit::telBarCBcurrentIndexChanged(int index)
{
if (telemetryLock) return;
QComboBox *comboBox = qobject_cast<QComboBox*>(sender());
int screenId = comboBox->objectName().mid(8,1).toInt() - 1;
int barId = comboBox->objectName().mid(10,1).toInt() - 1;
int bar=barId+screenId*4;
g_model.frsky.screens[screenId].body.bars[barId].source=index;
telemetryLock=true;
if (index==0) {
g_model.frsky.screens[screenId].body.bars[barId].barMin=0;
g_model.frsky.screens[screenId].body.bars[barId].barMax=0;
minSB[bar]->setDisabled(true);
maxSB[bar]->setDisabled(true);
} else {
minSB[bar]->setEnabled(true);
maxSB[bar]->setEnabled(true);
}
switch (index-1) {
case TELEMETRY_SOURCE_TX_BATT:
case TELEMETRY_SOURCE_A1:
case TELEMETRY_SOURCE_A1_MIN:
case TELEMETRY_SOURCE_A2:
case TELEMETRY_SOURCE_A2_MIN:
case TELEMETRY_SOURCE_CELLS_SUM:
case TELEMETRY_SOURCE_VFAS:
case TELEMETRY_SOURCE_CURRENT_MAX:
case TELEMETRY_SOURCE_CURRENT:
minSB[bar]->setDecimals(1);
maxSB[bar]->setDecimals(1);
break;
case TELEMETRY_SOURCE_CELL:
minSB[bar]->setDecimals(2);
maxSB[bar]->setDecimals(2);
break;
default:
minSB[bar]->setDecimals(0);
maxSB[bar]->setDecimals(0);
}
minSB[bar]->setMinimum(getBarValue(index, 0, &g_model.frsky));
minSB[bar]->setMaximum(getBarValue(index, 255, &g_model.frsky));
minSB[bar]->setSingleStep(getBarStep(index));
maxSB[bar]->setMinimum(getBarValue(index, 0, &g_model.frsky));
maxSB[bar]->setMaximum(getBarValue(index, 255, &g_model.frsky));
maxSB[bar]->setSingleStep(getBarStep(index));
minSB[bar]->setValue(getBarValue(index, g_model.frsky.screens[screenId].body.bars[barId].barMin, &g_model.frsky));
maxSB[bar]->setValue(getBarValue(index, 255-g_model.frsky.screens[screenId].body.bars[barId].barMax, &g_model.frsky));
telemetryLock=false;
updateSettings();
}
void ModelEdit::telMinSBeditingFinished()
{
if (telemetryLock) return;
QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox*>(sender());
int screenId = spinBox->objectName().mid(8,1).toInt() - 1;
int barId = spinBox->objectName().right(1).toInt() - 1;
int minId = barId+screenId*4;
telemetryLock=true;
if (g_model.frsky.screens[screenId].body.bars[barId].source==TELEMETRY_SOURCE_A1 || g_model.frsky.screens[screenId].body.bars[barId].source==TELEMETRY_SOURCE_A1_MIN) {
g_model.frsky.screens[screenId].body.bars[barId].barMin=round((minSB[minId]->value()-ui->a1CalibSB->value())/getBarStep(g_model.frsky.screens[screenId].body.bars[barId].source));
} else if (g_model.frsky.screens[screenId].body.bars[minId].source==TELEMETRY_SOURCE_A2 || g_model.frsky.screens[screenId].body.bars[minId].source==TELEMETRY_SOURCE_A2_MIN) {
g_model.frsky.screens[screenId].body.bars[barId].barMin=round((minSB[minId]->value()-ui->a2CalibSB->value())/getBarStep(g_model.frsky.screens[screenId].body.bars[barId].source));
} else {
g_model.frsky.screens[screenId].body.bars[barId].barMin=round((minSB[minId]->value()-getBarValue(g_model.frsky.screens[screenId].body.bars[barId].source, 0, &g_model.frsky))/getBarStep(g_model.frsky.screens[screenId].body.bars[barId].source));
}
spinBox->setValue(getBarValue(g_model.frsky.screens[screenId].body.bars[barId].source, g_model.frsky.screens[screenId].body.bars[barId].barMin, &g_model.frsky));
if (maxSB[minId]->value()<minSB[minId]->value()) {
g_model.frsky.screens[screenId].body.bars[minId].barMax=(255-g_model.frsky.screens[screenId].body.bars[barId].barMin+1);
maxSB[minId]->setValue(getBarValue(g_model.frsky.screens[screenId].body.bars[barId].source, 255-g_model.frsky.screens[screenId].body.bars[barId].barMax, &g_model.frsky));
}
maxSB[minId]->setMinimum(getBarValue(g_model.frsky.screens[screenId].body.bars[barId].source, (g_model.frsky.screens[screenId].body.bars[barId].barMin+1), &g_model.frsky));
telemetryLock=false;
updateSettings();
}
void ModelEdit::telMaxSBeditingFinished()
{
if (telemetryLock) return;
QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox*>(sender());
int screenId = spinBox->objectName().mid(8,1).toInt() - 1;
int barId = spinBox->objectName().right(1).toInt() - 1;
telemetryLock=true;
if (g_model.frsky.screens[screenId].body.bars[barId].source==5) {
g_model.frsky.screens[screenId].body.bars[barId].barMax = (255-round((spinBox->value()-ui->a1CalibSB->value())/getBarStep(g_model.frsky.screens[screenId].body.bars[barId].source)));
} else if (g_model.frsky.screens[screenId].body.bars[barId].source==6) {
g_model.frsky.screens[screenId].body.bars[barId].barMax = (255-round((spinBox->value()-ui->a2CalibSB->value())/getBarStep(g_model.frsky.screens[screenId].body.bars[barId].source)));
} else {
g_model.frsky.screens[screenId].body.bars[barId].barMax = (255-round((spinBox->value()-getBarValue(g_model.frsky.screens[screenId].body.bars[barId].source, 0, &g_model.frsky))/getBarStep(g_model.frsky.screens[screenId].body.bars[barId].source) ));
}
spinBox->setValue(getBarValue(g_model.frsky.screens[screenId].body.bars[barId].source, (255-g_model.frsky.screens[screenId].body.bars[barId].barMax), &g_model.frsky));
telemetryLock=false;
updateSettings();
}
void ModelEdit::on_thrTrimChkB_toggled(bool checked)
{
g_model.thrTrim = checked;
updateSettings();
}
void ModelEdit::on_thrExpoChkB_toggled(bool checked)
{
g_model.thrExpo = checked;
updateSettings();
}
void ModelEdit::on_AltitudeToolbar_ChkB_toggled(bool checked)
{
g_model.frsky.altitudeDisplayed = checked;
updateSettings();
}
void ModelEdit::on_bcRUDChkB_toggled(bool checked)
{
if(checked) {
g_model.beepANACenter |= BC_BIT_RUD;
} else {
g_model.beepANACenter &= ~BC_BIT_RUD;
}
updateSettings();
}
void ModelEdit::on_bcELEChkB_toggled(bool checked)
{
if(checked) {
g_model.beepANACenter |= BC_BIT_ELE;
} else {
g_model.beepANACenter &= ~BC_BIT_ELE;
}
updateSettings();
}
void ModelEdit::on_bcTHRChkB_toggled(bool checked)
{
if(checked) {
g_model.beepANACenter |= BC_BIT_THR;
} else {
g_model.beepANACenter &= ~BC_BIT_THR;
}
updateSettings();
}
void ModelEdit::on_bcAILChkB_toggled(bool checked)
{
if(checked) {
g_model.beepANACenter |= BC_BIT_AIL;
} else {
g_model.beepANACenter &= ~BC_BIT_AIL;
}
updateSettings();
}
void ModelEdit::on_bcP1ChkB_toggled(bool checked)
{
if(checked) {
g_model.beepANACenter |= BC_BIT_P1;
} else {
g_model.beepANACenter &= ~BC_BIT_P1;
}
updateSettings();
}
void ModelEdit::on_bcP2ChkB_toggled(bool checked)
{
if(checked) {
g_model.beepANACenter |= BC_BIT_P2;
} else {
g_model.beepANACenter &= ~BC_BIT_P2;
}
updateSettings();
}
void ModelEdit::on_bcP3ChkB_toggled(bool checked)
{
if(checked) {
g_model.beepANACenter |= BC_BIT_P3;
} else {
g_model.beepANACenter &= ~BC_BIT_P3;
}
updateSettings();
}
void ModelEdit::on_bcP4ChkB_toggled(bool checked)
{
if(checked) {
g_model.beepANACenter |= BC_BIT_P4;
} else {
g_model.beepANACenter &= ~BC_BIT_P4;
}
updateSettings();
}
void ModelEdit::on_bcREaChkB_toggled(bool checked)
{
if(checked) {
g_model.beepANACenter |= BC_BIT_REA;
} else {
g_model.beepANACenter &= ~BC_BIT_REA;
}
updateSettings();
}
void ModelEdit::on_bcREbChkB_toggled(bool checked)
{
if(checked) {
g_model.beepANACenter |= BC_BIT_REB;
} else {
g_model.beepANACenter &= ~BC_BIT_REB;
}
updateSettings();
}
void ModelEdit::phaseGVValue_editingFinished()
{
if (phasesLock) return;
QSpinBox *spinBox = qobject_cast<QSpinBox*>(sender());
int phase = spinBox->objectName().mid(5,1).toInt();
int gvar = spinBox->objectName().mid(8,1).toInt()-1;
g_model.phaseData[phase].gvars[gvar] = spinBox->value();
updateSettings();
}
void ModelEdit::GVName_editingFinished()
{
if (phasesLock) return;
QLineEdit *lineedit = qobject_cast<QLineEdit*>(sender());
int gvar = lineedit->objectName().mid(8,1).toInt()-1;
memset(&g_model.gvars_names[gvar],0,sizeof(g_model.gvars_names[gvar]));
const char * le=lineedit->text().toAscii();
strncpy(g_model.gvars_names[gvar], le, sizeof(g_model.gvars_names[gvar])-1);
updateSettings();
}
void ModelEdit::GVSource_currentIndexChanged()
{
QComboBox *comboBox = qobject_cast<QComboBox*>(sender());
int gvar = comboBox->objectName().mid(8,1).toInt()-1;
int index=comboBox->currentIndex();
g_model.gvsource[gvar]=index;
updateSettings();
}
void ModelEdit::phaseGVUse_currentIndexChanged()
{
if (phasesLock) return;
phasesLock=true;
QComboBox *comboBox = qobject_cast<QComboBox*>(sender());
int phase = comboBox->objectName().mid(5,1).toInt();
int gvar = comboBox->objectName().mid(8,1).toInt()-1;
int index=comboBox->currentIndex();
if (index == 0) {
int value=g_model.phaseData[phase].gvars[gvar];
if (value>1024) {
value=0;
}
gvarsSB[phase][gvar]->setValue(value);
gvarsSB[phase][gvar]->setEnabled(true);
g_model.phaseData[phase].gvars[gvar]=value;
} else {
g_model.phaseData[phase].gvars[gvar]=1024+index;
int value=gvarsSB[index+(index>phase ?0 :-1)][gvar]->value();
gvarsSB[phase][gvar]->setValue(value);
gvarsSB[phase][gvar]->setDisabled(true);
}
phasesLock=false;
updateSettings();
}
void ModelEdit::phaseREValue_editingFinished()
{
if (phasesLock) return;
QSpinBox *spinBox = qobject_cast<QSpinBox*>(sender());
int phase = spinBox->objectName().mid(5,1).toInt();
int gvar = spinBox->objectName().mid(8,1).toInt()-1;
g_model.phaseData[phase].rotaryEncoders[gvar] = spinBox->value();
updateSettings();
}
void ModelEdit::phaseREUse_currentIndexChanged()
{
if (phasesLock) return;
phasesLock=true;
QComboBox *comboBox = qobject_cast<QComboBox*>(sender());
int phase = comboBox->objectName().mid(5,1).toInt();
int re = comboBox->objectName().mid(8,1).toInt()-1;
int index=comboBox->currentIndex();
if (index == 0) {
int value=g_model.phaseData[phase].rotaryEncoders[re];
if (value>1024) {
value=0;
}
reSB[phase][re]->setValue(value);
reSB[phase][re]->setEnabled(true);
g_model.phaseData[phase].rotaryEncoders[re]=value;
} else {
g_model.phaseData[phase].rotaryEncoders[re]=1024+index;
int value=reSB[index+(index>phase ?0 :-1)][re]->value();
reSB[phase][re]->setValue(value);
reSB[phase][re]->setDisabled(true) ;
}
phasesLock=false;
updateSettings();
}
void ModelEdit::phaseTrimUse_currentIndexChanged()
{
if (phasesLock) return;
QComboBox *comboBox = qobject_cast<QComboBox*>(sender());
int phase = comboBox->objectName().mid(5,1).toInt();
int trim = comboBox->objectName().mid(10,1).toInt();
int chn = CONVERT_MODE(trim)-1;
int index=comboBox->currentIndex();
if (index == 0) {
g_model.phaseData[phase].trim[chn] = g_model.phaseData[g_model.getTrimFlightPhase(chn, phase)].trim[chn];
g_model.phaseData[phase].trimRef[chn] = -1;
} else {
g_model.phaseData[phase].trim[chn] = 0;
g_model.phaseData[phase].trimRef[chn] = index - 1 + (index > (int)phase ? 1 : 0);
}
phasesLock = true;
displayOnePhaseOneTrim(phase, chn, NULL, phasesTrimValues[phase][trim-1], phasesTrimSliders[phase][trim-1]);
phasesLock = false;
updateSettings();
}
void ModelEdit::phaseTrim_valueChanged()
{
if (phasesLock) return;
QSpinBox *spinBox = qobject_cast<QSpinBox*>(sender());
int phase = spinBox->objectName().mid(5,1).toInt();
int trim = spinBox->objectName().mid(10,1).toInt();
int chn = CONVERT_MODE(trim)-1;
g_model.phaseData[phase].trim[chn] = spinBox->value();
phasesLock=true;
phasesTrimSliders[phase][trim-1]->setValue(spinBox->value());
phasesLock=false;
updateSettings();
}
void ModelEdit::phaseTrimSlider_valueChanged()
{
if (phasesLock) return;
QSlider *slider = qobject_cast<QSlider*>(sender());
int phase = slider->objectName().mid(5,1).toInt();
int trim = slider->objectName().mid(10,1).toInt();
int chn = CONVERT_MODE(trim)-1;
g_model.phaseData[phase].trim[chn] = slider->value();
phasesLock=true;
phasesTrimValues[phase][trim-1]->setValue(slider->value());
phasesLock=false;
updateSettings();
}
QSpinBox *ModelEdit::getNodeSB(int i) // get the SpinBox that corresponds to the selected node
{
return spny[i];
}
QSpinBox *ModelEdit::getNodeSBX(int i) // get the SpinBox that corresponds to the selected node
{
return spnx[i];
}
void ModelEdit::drawCurve()
{
if (drawing)
return;
drawing=true;
curvesLock=true;
int k,i;
QColor * plot_color[16];
plot_color[0]=new QColor(0,0,127);
plot_color[1]=new QColor(0,127,0);
plot_color[2]=new QColor(127,0,0);
plot_color[3]=new QColor(0,127,127);
plot_color[4]=new QColor(127,0,127);
plot_color[5]=new QColor(127,127,0);
plot_color[6]=new QColor(127,127,127);
plot_color[7]=new QColor(0,0,255);
plot_color[8]=new QColor(0,127,255);
plot_color[9]=new QColor(127,0,255);
plot_color[10]=new QColor(0,255,0);
plot_color[11]=new QColor(0,255,127);
plot_color[12]=new QColor(127,255,0);
plot_color[13]=new QColor(255,0,0);
plot_color[14]=new QColor(255,0,127);
plot_color[15]=new QColor(255,127,0);
if(currentCurve<0 || currentCurve>15) return;
Node *nodel = 0;
Node *nodex = 0;
QGraphicsScene *scene = ui->curvePreview->scene();
QPen pen;
QColor color;
scene->clear();
qreal width = scene->sceneRect().width();
qreal height = scene->sceneRect().height();
qreal centerX = scene->sceneRect().left() + width/2; //center X
qreal centerY = scene->sceneRect().top() + height/2; //center Y
QGraphicsSimpleTextItem *ti;
ti = scene->addSimpleText(tr("Editing curve %1").arg(currentCurve+1));
ti->setPos(3,3);
scene->addLine(centerX,GFX_MARGIN,centerX,height+GFX_MARGIN);
scene->addLine(GFX_MARGIN,centerY,width+GFX_MARGIN,centerY);
pen.setWidth(2);
pen.setStyle(Qt::SolidLine);
int numcurves=GetEepromInterface()->getCapability(NumCurves);
if (numcurves==0) {
numcurves=16;
}
for(k=0; k<numcurves; k++) {
pen.setColor(*plot_color[k]);
if ((currentCurve!=k) && (plot_curve[k])) {
int numpoints=g_model.curves[k].count;
for(i=0; i<(numpoints-1); i++) {
if (!g_model.curves[k].custom) {
scene->addLine(GFX_MARGIN + i*width/(numpoints-1),centerY - (qreal)g_model.curves[k].points[i].y*height/200,GFX_MARGIN + (i+1)*width/(numpoints-1),centerY - (qreal)g_model.curves[k].points[i+1].y*height/200,pen);
} else {
scene->addLine(centerX + (qreal)g_model.curves[k].points[i].x*width/200,centerY - (qreal)g_model.curves[k].points[i].y*height/200,centerX + (qreal)g_model.curves[k].points[i+1].x*width/200,centerY - (qreal)g_model.curves[k].points[i+1].y*height/200,pen);
}
}
}
}
int numpoints=g_model.curves[currentCurve].count;
for(int i=0; i<numpoints; i++) {
nodel = nodex;
nodex = new Node(getNodeSB(i),getNodeSBX(i));
nodex->setColor(*plot_color[currentCurve]);
if (!g_model.curves[currentCurve].custom) {
nodex->setFixedX(true);
nodex->setPos(GFX_MARGIN + i*width/(numpoints-1),centerY - (qreal)g_model.curves[currentCurve].points[i].y*height/200);
} else {
if (i>0 && i<(numpoints-1)) {
nodex->setFixedX(false);
nodex->setMinX(g_model.curves[currentCurve].points[i-1].x+1);
nodex->setMaxX(g_model.curves[currentCurve].points[i+1].x-1);
spnx[i]->setMaximum(g_model.curves[currentCurve].points[i+1].x-1);
spnx[i]->setMinimum(g_model.curves[currentCurve].points[i-1].x+1);
} else {
nodex->setFixedX(true);
}
nodex->setPos(centerX + (qreal)g_model.curves[currentCurve].points[i].x*width/200,centerY - (qreal)g_model.curves[currentCurve].points[i].y*height/200);
}
scene->addItem(nodex);
if(i>0) scene->addItem(new Edge(nodel, nodex));
}
curvesLock=false;
drawing=false;
}
bool ModelEdit::gm_insertMix(int idx)
{
if (idx<0 || idx>=GetEepromInterface()->getCapability(Mixes) || g_model.mixData[GetEepromInterface()->getCapability(Mixes)-1].destCh > 0) {
QMessageBox::information(this, "Companion", tr("Not enough available mixers!"));
return false;
}
int i = g_model.mixData[idx].destCh;
memmove(&g_model.mixData[idx+1],&g_model.mixData[idx],
(GetEepromInterface()->getCapability(Mixes)-(idx+1))*sizeof(MixData) );
memset(&g_model.mixData[idx],0,sizeof(MixData));
g_model.mixData[idx].srcRaw = RawSource(SOURCE_TYPE_NONE);
g_model.mixData[idx].destCh = i;
g_model.mixData[idx].weight = 100;
return true;
}
void ModelEdit::gm_deleteMix(int index)
{
memmove(&g_model.mixData[index],&g_model.mixData[index+1],
(GetEepromInterface()->getCapability(Mixes)-(index+1))*sizeof(MixData));
memset(&g_model.mixData[GetEepromInterface()->getCapability(Mixes)-1],0,sizeof(MixData));
}
void ModelEdit::gm_openMix(int index)
{
if(index<0 || index>=GetEepromInterface()->getCapability(Mixes)) return;
MixData mixd(g_model.mixData[index]);
updateSettings();
tabMixes();
MixerDialog *g = new MixerDialog(this, &mixd, g_eeGeneral.stickMode);
if(g->exec()) {
g_model.mixData[index] = mixd;
updateSettings();
tabMixes();
} else {
if (mixInserted) {
gm_deleteMix(index);
}
mixInserted=false;
updateSettings();
tabMixes();
}
}
int ModelEdit::getMixerIndex(unsigned int dch)
{
int i = 0;
while ((g_model.mixData[i].destCh<=dch) && (g_model.mixData[i].destCh) && (i<GetEepromInterface()->getCapability(Mixes))) i++;
if(i==GetEepromInterface()->getCapability(Mixes)) return -1;
return i;
}
bool ModelEdit::gm_insertExpo(int idx)
{
if (idx<0 || idx>=C9X_MAX_EXPOS || g_model.expoData[C9X_MAX_EXPOS-1].mode > 0) {
QMessageBox::information(this, "Companion", tr("Not enough available expos!"));
return false;
}
int chn = g_model.expoData[idx].chn;
memmove(&g_model.expoData[idx+1],&g_model.expoData[idx],
(C9X_MAX_EXPOS-(idx+1))*sizeof(ExpoData) );
memset(&g_model.expoData[idx],0,sizeof(ExpoData));
g_model.expoData[idx].chn = chn;
g_model.expoData[idx].weight = 100;
g_model.expoData[idx].mode = 3 /* TODO enum */;
return true;
}
void ModelEdit::gm_deleteExpo(int index)
{
memmove(&g_model.expoData[index],&g_model.expoData[index+1],
(C9X_MAX_EXPOS-(index+1))*sizeof(ExpoData));
memset(&g_model.expoData[C9X_MAX_EXPOS-1],0,sizeof(ExpoData));
}
void ModelEdit::gm_openExpo(int index)
{
if(index<0 || index>=C9X_MAX_EXPOS) return;
ExpoData mixd(g_model.expoData[index]);
updateSettings();
tabExpos();
ExpoDialog *g = new ExpoDialog(this, &mixd, g_eeGeneral.stickMode);
if(g->exec()) {
g_model.expoData[index] = mixd;
updateSettings();
tabExpos();
} else {
if (expoInserted) {
gm_deleteExpo(index);
}
expoInserted=false;
updateSettings();
tabExpos();
}
}
int ModelEdit::getExpoIndex(unsigned int dch)
{
unsigned int i = 0;
while (g_model.expoData[i].chn<=dch && g_model.expoData[i].mode && i<C9X_MAX_EXPOS) i++;
if(i==C9X_MAX_EXPOS) return -1;
return i;
}
void ModelEdit::mixerlistWidget_doubleClicked(QModelIndex index)
{
int idx= MixerlistWidget->item(index.row())->data(Qt::UserRole).toByteArray().at(0);
if (idx<0) {
int i = -idx;
idx = getMixerIndex(i); //get mixer index to insert
if (!gm_insertMix(idx))
return;
g_model.mixData[idx].destCh = i;
mixInserted=true;
} else {
mixInserted=false;
}
gm_openMix(idx);
}
void ModelEdit::expolistWidget_doubleClicked(QModelIndex index)
{
expoOpen(ExposlistWidget->item(index.row()));
}
void ModelEdit::exposDeleteList(QList<int> list)
{
qSort(list.begin(), list.end());
int iDec = 0;
foreach(int idx, list) {
gm_deleteExpo(idx-iDec);
iDec++;
}
}
void ModelEdit::mixersDeleteList(QList<int> list)
{
qSort(list.begin(), list.end());
int iDec = 0;
foreach(int idx, list) {
gm_deleteMix(idx-iDec);
iDec++;
}
}
QList<int> ModelEdit::createMixListFromSelected()
{
QList<int> list;
foreach(QListWidgetItem *item, MixerlistWidget->selectedItems()) {
int idx= item->data(Qt::UserRole).toByteArray().at(0);
if(idx>=0 && idx<GetEepromInterface()->getCapability(Mixes)) list << idx;
}
return list;
}
QList<int> ModelEdit::createExpoListFromSelected()
{
QList<int> list;
foreach(QListWidgetItem *item, ExposlistWidget->selectedItems()) {
int idx= item->data(Qt::UserRole).toByteArray().at(0);
if(idx>=0 && idx<C9X_MAX_EXPOS) list << idx;
}
return list;
}
// TODO duplicated code
void ModelEdit::setSelectedByMixList(QList<int> list)
{
for(int i=0; i<MixerlistWidget->count(); i++) {
int t = MixerlistWidget->item(i)->data(Qt::UserRole).toByteArray().at(0);
if(list.contains(t))
MixerlistWidget->item(i)->setSelected(true);
}
}
void ModelEdit::setSelectedByExpoList(QList<int> list)
{
for(int i=0; i<ExposlistWidget->count(); i++) {
int t = ExposlistWidget->item(i)->data(Qt::UserRole).toByteArray().at(0);
if(list.contains(t))
ExposlistWidget->item(i)->setSelected(true);
}
}
void ModelEdit::mixersDelete(bool ask)
{
QMessageBox::StandardButton ret = QMessageBox::No;
if(ask)
ret = QMessageBox::warning(this, "Companion",
tr("Delete Selected Mixes?"),
QMessageBox::Yes | QMessageBox::No);
if ((ret == QMessageBox::Yes) || (!ask)) {
mixersDeleteList(createMixListFromSelected());
updateSettings();
tabMixes();
}
}
void ModelEdit::mixersCut()
{
mixersCopy();
mixersDelete(false);
}
void ModelEdit::mixersCopy()
{
QList<int> list = createMixListFromSelected();
QByteArray mxData;
foreach(int idx, list) {
mxData.append((char*)&g_model.mixData[idx],sizeof(MixData));
}
QMimeData *mimeData = new QMimeData;
mimeData->setData("application/x-companion9x-mix", mxData);
QApplication::clipboard()->setMimeData(mimeData,QClipboard::Clipboard);
}
void ModelEdit::exposDelete(bool ask)
{
QMessageBox::StandardButton ret = QMessageBox::No;
if(ask)
ret = QMessageBox::warning(this, "Companion",
tr("Delete Selected Expos?"),
QMessageBox::Yes | QMessageBox::No);
if ((ret == QMessageBox::Yes) || (!ask)) {
exposDeleteList(createExpoListFromSelected());
updateSettings();
tabExpos();
}
}
void ModelEdit::exposCut()
{
exposCopy();
exposDelete(false);
}
void ModelEdit::exposCopy()
{
QList<int> list = createExpoListFromSelected();
QByteArray mxData;
foreach(int idx, list) {
mxData.append((char*)&g_model.expoData[idx],sizeof(ExpoData));
}
QMimeData *mimeData = new QMimeData;
mimeData->setData("application/x-companion9x-expo", mxData);
QApplication::clipboard()->setMimeData(mimeData,QClipboard::Clipboard);
}
void ModelEdit::mimeExpoDropped(int index, const QMimeData *data, Qt::DropAction /*action*/)
{
int idx = ExposlistWidget->item(index > 0 ? index-1 : 0)->data(Qt::UserRole).toByteArray().at(0);
pasteExpoMimeData(data, idx);
}
void ModelEdit::mimeMixerDropped(int index, const QMimeData *data, Qt::DropAction /*action*/)
{
int idx= MixerlistWidget->item(index > 0 ? index-1 : 0)->data(Qt::UserRole).toByteArray().at(0);
pasteMixerMimeData(data, idx);
}
void ModelEdit::pasteMixerMimeData(const QMimeData * mimeData, int destIdx)
{
if(mimeData->hasFormat("application/x-companion9x-mix")) {
int idx; // mixer index
int dch;
if(destIdx<0) {
dch = -destIdx;
idx = getMixerIndex(dch) - 1; //get mixer index to insert
} else {
idx = destIdx;
dch = g_model.mixData[idx].destCh;
}
QByteArray mxData = mimeData->data("application/x-companion9x-mix");
int i = 0;
while(i<mxData.size()) {
idx++;
if(idx==GetEepromInterface()->getCapability(Mixes)) break;
if (!gm_insertMix(idx))
break;
MixData *md = &g_model.mixData[idx];
memcpy(md,mxData.mid(i,sizeof(MixData)).constData(),sizeof(MixData));
md->destCh = dch;
i += sizeof(MixData);
}
updateSettings();
tabMixes();
}
}
#include <iostream>
#include <QtGui/qwidget.h>
void ModelEdit::pasteExpoMimeData(const QMimeData * mimeData, int destIdx)
{
if (mimeData->hasFormat("application/x-companion9x-expo")) {
int idx; // mixer index
int dch;
if (destIdx < 0) {
dch = -destIdx - 1;
idx = getExpoIndex(dch) - 1; //get expo index to insert
} else {
idx = destIdx;
dch = g_model.expoData[idx].chn;
}
QByteArray mxData = mimeData->data("application/x-companion9x-expo");
int i = 0;
while (i < mxData.size()) {
idx++;
if (!gm_insertExpo(idx))
break;
ExpoData *md = &g_model.expoData[idx];
memcpy(md, mxData.mid(i, sizeof(ExpoData)).constData(), sizeof(ExpoData));
md->chn = dch;
i += sizeof(ExpoData);
}
updateSettings();
tabExpos();
}
}
void ModelEdit::mixersPaste()
{
const QClipboard *clipboard = QApplication::clipboard();
const QMimeData *mimeData = clipboard->mimeData();
QListWidgetItem *item = MixerlistWidget->currentItem();
if (item)
pasteMixerMimeData(mimeData, item->data(Qt::UserRole).toByteArray().at(0));
}
void ModelEdit::mixersDuplicate()
{
mixersCopy();
mixersPaste();
}
void ModelEdit::exposPaste()
{
const QClipboard *clipboard = QApplication::clipboard();
const QMimeData *mimeData = clipboard->mimeData();
QListWidgetItem *item = ExposlistWidget->currentItem();
if (item)
pasteExpoMimeData(mimeData, item->data(Qt::UserRole).toByteArray().at(0));
}
void ModelEdit::exposDuplicate()
{
exposCopy();
exposPaste();
}
void ModelEdit::mixerOpen()
{
int idx = MixerlistWidget->currentItem()->data(Qt::UserRole).toByteArray().at(0);
if(idx<0) {
int i = -idx;
idx = getMixerIndex(i); //get mixer index to insert
if (!gm_insertMix(idx))
return;
g_model.mixData[idx].destCh = i;
mixInserted=true;
} else {
mixInserted=false;
}
gm_openMix(idx);
}
void ModelEdit::mixerAdd()
{
if (!MixerlistWidget->currentItem())
return;
int index = MixerlistWidget->currentItem()->data(Qt::UserRole).toByteArray().at(0);
if(index<0) { // if empty then return relavent index
int i = -index;
index = getMixerIndex(i); //get mixer index to insert
if (!gm_insertMix(index))
return;
g_model.mixData[index].destCh = i;
mixInserted=true;
} else {
index++;
if (!gm_insertMix(index))
return;
g_model.mixData[index].destCh = g_model.mixData[index-1].destCh;
mixInserted=true;
}
gm_openMix(index);
}
void ModelEdit::expoOpen(QListWidgetItem *item)
{
if (!item)
item = ExposlistWidget->currentItem();
int idx = item->data(Qt::UserRole).toByteArray().at(0);
if (idx<0) {
int ch = -idx-1;
idx = getExpoIndex(ch); // get expo index to insert
if (!gm_insertExpo(idx))
return;
g_model.expoData[idx].chn = ch;
expoInserted=true;
} else {
expoInserted=false;
}
gm_openExpo(idx);
}
void ModelEdit::expoAdd()
{
int index = ExposlistWidget->currentItem()->data(Qt::UserRole).toByteArray().at(0);
if(index<0) { // if empty then return relevant index
expoOpen();
} else {
index++;
if (!gm_insertExpo(index))
return;
g_model.expoData[index].chn = g_model.expoData[index-1].chn;
}
gm_openExpo(index);
}
void ModelEdit::mixerlistWidget_customContextMenuRequested(QPoint pos)
{
QPoint globalPos = MixerlistWidget->mapToGlobal(pos);
const QClipboard *clipboard = QApplication::clipboard();
const QMimeData *mimeData = clipboard->mimeData();
bool hasData = mimeData->hasFormat("application/x-companion9x-mix");
QMenu contextMenu;
contextMenu.addAction(QIcon(":/images/add.png"), tr("&Add"),this,SLOT(mixerAdd()),tr("Ctrl+A"));
contextMenu.addAction(QIcon(":/images/edit.png"), tr("&Edit"),this,SLOT(mixerOpen()),tr("Enter"));
contextMenu.addSeparator();
contextMenu.addAction(QIcon(":/images/clear.png"), tr("&Delete"),this,SLOT(mixersDelete()),tr("Delete"));
contextMenu.addAction(QIcon(":/images/copy.png"), tr("&Copy"),this,SLOT(mixersCopy()),tr("Ctrl+C"));
contextMenu.addAction(QIcon(":/images/cut.png"), tr("&Cut"),this,SLOT(mixersCut()),tr("Ctrl+X"));
contextMenu.addAction(QIcon(":/images/paste.png"), tr("&Paste"),this,SLOT(mixersPaste()),tr("Ctrl+V"))->setEnabled(hasData);
contextMenu.addAction(QIcon(":/images/duplicate.png"), tr("Du&plicate"),this,SLOT(mixersDuplicate()),tr("Ctrl+U"));
contextMenu.addSeparator();
contextMenu.addAction(QIcon(":/images/moveup.png"), tr("Move Up"),this,SLOT(moveMixUp()),tr("Ctrl+Up"));
contextMenu.addAction(QIcon(":/images/movedown.png"), tr("Move Down"),this,SLOT(moveMixDown()),tr("Ctrl+Down"));
contextMenu.exec(globalPos);
}
void ModelEdit::expolistWidget_customContextMenuRequested(QPoint pos)
{
QPoint globalPos = ExposlistWidget->mapToGlobal(pos);
const QClipboard *clipboard = QApplication::clipboard();
const QMimeData *mimeData = clipboard->mimeData();
bool hasData = mimeData->hasFormat("application/x-companion9x-expo");
QMenu contextMenu;
contextMenu.addAction(QIcon(":/images/add.png"), tr("&Add"),this,SLOT(expoAdd()),tr("Ctrl+A"));
contextMenu.addAction(QIcon(":/images/edit.png"), tr("&Edit"),this,SLOT(expoOpen()),tr("Enter"));
contextMenu.addSeparator();
contextMenu.addAction(QIcon(":/images/clear.png"), tr("&Delete"),this,SLOT(exposDelete()),tr("Delete"));
contextMenu.addAction(QIcon(":/images/copy.png"), tr("&Copy"),this,SLOT(exposCopy()),tr("Ctrl+C"));
contextMenu.addAction(QIcon(":/images/cut.png"), tr("&Cut"),this,SLOT(exposCut()),tr("Ctrl+X"));
contextMenu.addAction(QIcon(":/images/paste.png"), tr("&Paste"),this,SLOT(exposPaste()),tr("Ctrl+V"))->setEnabled(hasData);
contextMenu.addAction(QIcon(":/images/duplicate.png"), tr("Du&plicate"),this,SLOT(exposDuplicate()),tr("Ctrl+U"));
contextMenu.addSeparator();
contextMenu.addAction(QIcon(":/images/moveup.png"), tr("Move Up"),this,SLOT(moveExpoUp()),tr("Ctrl+Up"));
contextMenu.addAction(QIcon(":/images/movedown.png"), tr("Move Down"),this,SLOT(moveExpoDown()),tr("Ctrl+Down"));
contextMenu.exec(globalPos);
}
void ModelEdit::cswPaste()
{
const QClipboard *clipboard = QApplication::clipboard();
const QMimeData *mimeData = clipboard->mimeData();
if (mimeData->hasFormat("application/x-companion9x-csw")) {
QByteArray cswData = mimeData->data("application/x-companion9x-csw");
CustomSwData *csw = &g_model.customSw[selectedSwitch];
memcpy(csw, cswData.mid(0, sizeof(CustomSwData)).constData(), sizeof(CustomSwData));
updateSettings();
updateSelectedSwitch();
}
}
void ModelEdit::cswDelete()
{
g_model.customSw[selectedSwitch].clear();
updateSettings();
updateSelectedSwitch();
}
void ModelEdit::cswCopy()
{
QByteArray cswData;
cswData.append((char*)&g_model.customSw[selectedSwitch],sizeof(CustomSwData));
QMimeData *mimeData = new QMimeData;
mimeData->setData("application/x-companion9x-csw", cswData);
QApplication::clipboard()->setMimeData(mimeData,QClipboard::Clipboard);
}
void ModelEdit::updateSelectedSwitch()
{
switchEditLock = true;
populateCSWCB(csw[selectedSwitch], g_model.customSw[selectedSwitch].func);
setSwitchWidgetVisibility(selectedSwitch);
switchEditLock = false;
}
void ModelEdit::cswCut()
{
cswCopy();
cswDelete();
}
void ModelEdit::csw_customContextMenuRequested(QPoint pos)
{
QLabel *label = (QLabel *)sender();
if (!label)
return;
QString name=label->objectName();
if (!name.startsWith("cswlabel"))
return;
selectedSwitch=name.mid(9,2).toInt()-1;
QPoint globalPos = label->mapToGlobal(pos);
const QClipboard *clipboard = QApplication::clipboard();
const QMimeData *mimeData = clipboard->mimeData();
bool hasData = mimeData->hasFormat("application/x-companion9x-csw");
QMenu contextMenu;
contextMenu.addAction(QIcon(":/images/clear.png"), tr("&Delete"),this,SLOT(cswDelete()),tr("Delete"));
contextMenu.addAction(QIcon(":/images/copy.png"), tr("&Copy"),this,SLOT(cswCopy()),tr("Ctrl+C"));
contextMenu.addAction(QIcon(":/images/cut.png"), tr("&Cut"),this,SLOT(cswCut()),tr("Ctrl+X"));
contextMenu.addAction(QIcon(":/images/paste.png"), tr("&Paste"),this,SLOT(cswPaste()),tr("Ctrl+V"))->setEnabled(hasData);
contextMenu.exec(globalPos);
}
void ModelEdit::fsw_customContextMenuRequested(QPoint pos)
{
QLabel *label = (QLabel *)sender();
if (!label)
return;
int fsw=label->property("FunctionId").toInt();
if (!(fsw>0 && fsw<=32))
return;
selectedFunction=fsw-1;
QPoint globalPos = label->mapToGlobal(pos);
const QClipboard *clipboard = QApplication::clipboard();
const QMimeData *mimeData = clipboard->mimeData();
bool hasData = mimeData->hasFormat("application/x-companion9x-fsw");
QMenu contextMenu;
contextMenu.addAction(QIcon(":/images/clear.png"), tr("&Delete"),this,SLOT(fswDelete()),tr("Delete"));
contextMenu.addAction(QIcon(":/images/copy.png"), tr("&Copy"),this,SLOT(fswCopy()),tr("Ctrl+C"));
contextMenu.addAction(QIcon(":/images/cut.png"), tr("&Cut"),this,SLOT(fswCut()),tr("Ctrl+X"));
contextMenu.addAction(QIcon(":/images/paste.png"), tr("&Paste"),this,SLOT(fswPaste()),tr("Ctrl+V"))->setEnabled(hasData);
contextMenu.exec(globalPos);
}
void ModelEdit::fswPaste()
{
const QClipboard *clipboard = QApplication::clipboard();
const QMimeData *mimeData = clipboard->mimeData();
if (mimeData->hasFormat("application/x-companion9x-fsw")) {
QByteArray fswData = mimeData->data("application/x-companion9x-fsw");
FuncSwData *fsw = &g_model.funcSw[selectedFunction];
memcpy(fsw, fswData.mid(0, sizeof(FuncSwData)).constData(), sizeof(FuncSwData));
updateSettings();
tabCustomFunctions();
}
}
void ModelEdit::fswDelete()
{
g_model.funcSw[selectedFunction].clear();
updateSettings();
tabCustomFunctions();
}
void ModelEdit::fswCopy()
{
QByteArray fswData;
fswData.append((char*)&g_model.funcSw[selectedFunction],sizeof(FuncSwData));
QMimeData *mimeData = new QMimeData;
mimeData->setData("application/x-companion9x-fsw", fswData);
QApplication::clipboard()->setMimeData(mimeData,QClipboard::Clipboard);
}
void ModelEdit::fswCut()
{
fswCopy();
fswDelete();
}
void ModelEdit::mixerlistWidget_KeyPress(QKeyEvent *event)
{
if(event->matches(QKeySequence::SelectAll)) mixerAdd(); //Ctrl A
if(event->matches(QKeySequence::Delete)) mixersDelete();
if(event->matches(QKeySequence::Copy)) mixersCopy();
if(event->matches(QKeySequence::Cut)) mixersCut();
if(event->matches(QKeySequence::Paste)) mixersPaste();
if(event->matches(QKeySequence::Underline)) mixersDuplicate();
if(event->key()==Qt::Key_Return || event->key()==Qt::Key_Enter) mixerOpen();
if(event->matches(QKeySequence::MoveToNextLine))
MixerlistWidget->setCurrentRow(MixerlistWidget->currentRow()+1);
if(event->matches(QKeySequence::MoveToPreviousLine))
MixerlistWidget->setCurrentRow(MixerlistWidget->currentRow()-1);
}
void ModelEdit::expolistWidget_KeyPress(QKeyEvent *event)
{
if(event->matches(QKeySequence::SelectAll)) expoAdd(); //Ctrl A
if(event->matches(QKeySequence::Delete)) exposDelete();
if(event->matches(QKeySequence::Copy)) exposCopy();
if(event->matches(QKeySequence::Cut)) exposCut();
if(event->matches(QKeySequence::Paste)) exposPaste();
if(event->matches(QKeySequence::Underline)) exposDuplicate();
if(event->key()==Qt::Key_Return || event->key()==Qt::Key_Enter) expoOpen();
if(event->matches(QKeySequence::MoveToNextLine))
ExposlistWidget->setCurrentRow(ExposlistWidget->currentRow()+1);
if(event->matches(QKeySequence::MoveToPreviousLine))
ExposlistWidget->setCurrentRow(ExposlistWidget->currentRow()-1);
}
int ModelEdit::gm_moveMix(int idx, bool dir) //true=inc=down false=dec=up
{
if(idx>GetEepromInterface()->getCapability(Mixes) || (idx==0 && !dir) || (idx==GetEepromInterface()->getCapability(Mixes) && dir)) return idx;
int tdx = dir ? idx+1 : idx-1;
MixData &src=g_model.mixData[idx];
MixData &tgt=g_model.mixData[tdx];
unsigned int outputs = GetEepromInterface()->getCapability(Outputs);
if((src.destCh==0) || (src.destCh>outputs) || (tgt.destCh>outputs)) return idx;
if(tgt.destCh!=src.destCh) {
if ((dir) && (src.destCh<outputs)) src.destCh++;
if ((!dir) && (src.destCh>0)) src.destCh--;
return idx;
}
//flip between idx and tgt
MixData temp;
memcpy(&temp,&src,sizeof(MixData));
memcpy(&src,&tgt,sizeof(MixData));
memcpy(&tgt,&temp,sizeof(MixData));
return tdx;
}
void ModelEdit::moveMixUp()
{
QList<int> list = createMixListFromSelected();
QList<int> highlightList;
foreach(int idx, list) {
highlightList << gm_moveMix(idx, false);
}
updateSettings();
tabMixes();
setSelectedByMixList(highlightList);
}
void ModelEdit::moveMixDown()
{
QList<int> list = createMixListFromSelected();
QList<int> highlightList;
foreach(int idx, list) {
highlightList << gm_moveMix(idx, true);
}
updateSettings();
tabMixes();
setSelectedByMixList(highlightList);
}
int ModelEdit::gm_moveExpo(int idx, bool dir) //true=inc=down false=dec=up
{
if(idx>C9X_MAX_EXPOS || (idx==C9X_MAX_EXPOS && dir)) return idx;
int tdx = dir ? idx+1 : idx-1;
ExpoData temp;
temp.clear();
ExpoData &src=g_model.expoData[idx];
ExpoData &tgt=g_model.expoData[tdx];
if (!dir && tdx<0 && src.chn>0) {
src.chn--;
return idx;
} else if (!dir && tdx<0) {
return idx;
}
if(memcmp(&src,&temp,sizeof(ExpoData))==0) return idx;
bool tgtempty=(memcmp(&tgt,&temp,sizeof(ExpoData))==0 ? 1:0);
if(tgt.chn!=src.chn || tgtempty) {
if ((dir) && (src.chn<(NUM_STICKS-1))) src.chn++;
if ((!dir) && (src.chn>0)) src.chn--;
return idx;
}
//flip between idx and tgt
memcpy(&temp,&src,sizeof(ExpoData));
memcpy(&src,&tgt,sizeof(ExpoData));
memcpy(&tgt,&temp,sizeof(ExpoData));
return tdx;
}
void ModelEdit::moveExpoUp()
{
QList<int> list = createExpoListFromSelected();
QList<int> highlightList;
foreach(int idx, list) {
highlightList << gm_moveExpo(idx, false);
}
updateSettings();
tabExpos();
setSelectedByExpoList(highlightList);
}
void ModelEdit::moveExpoDown()
{
QList<int> list = createExpoListFromSelected();
QList<int> highlightList;
foreach(int idx, list) {
highlightList << gm_moveExpo(idx, true);
}
updateSettings();
tabExpos();
setSelectedByExpoList(highlightList);
}
void ModelEdit::launchSimulation()
{
if (GetEepromInterface()->getSimulator()) {
RadioData *simuData = new RadioData;
*simuData = radioData;
simuData->models[id_model] = g_model;
if (GetEepromInterface()->getCapability(SimulatorType)) {
xsimulatorDialog sd(this);
sd.loadParams(*simuData, id_model);
sd.exec();
} else {
simulatorDialog sd(this);
sd.loadParams(*simuData, id_model);
sd.exec();
}
} else {
QMessageBox::warning(NULL,
QObject::tr("Warning"),
QObject::tr("Simulator for this firmware is not yet available"));
}
}
void ModelEdit::on_pushButton_clicked()
{
launchSimulation();
}
void ModelEdit::resetCurve()
{
QPushButton *button = (QPushButton *)sender();
int btn=button->objectName().mid(button->objectName().lastIndexOf("_")+1).toInt()-1;
if (btn!=currentCurve) {
int res = QMessageBox::question(this, "Companion",tr("Are you sure you want to delete curve %1 ?").arg(btn+1),QMessageBox::Yes | QMessageBox::No);
if (res == QMessageBox::No) {
return;
}
}
memset(g_model.curves[btn].name,0,sizeof(g_model.curves[btn].name));
ui->cname_LE->clear();
g_model.curves[btn].count=5;
g_model.curves[btn].custom=false;
curvesLock=true;
for (int i=0; i<17; i++) {
g_model.curves[btn].points[i].x=0;
g_model.curves[btn].points[i].y=0;
spnx[i]->setMinimum(-100);
spnx[i]->setMaximum(100);
spnx[i]->setValue(0);
spny[i]->setValue(0);
}
curvesLock=false;
updateCurvesTab();
if (btn==currentCurve) {
ui->curvetype_CB->setCurrentIndex(2);
}
updateSettings();
drawCurve();
}
void ModelEdit::editCurve()
{
QPushButton *button = (QPushButton *)sender();
int btn=button->objectName().mid(button->objectName().lastIndexOf("_")+1).toInt()-1;
setCurrentCurve(btn);
drawCurve();
}
void ModelEdit::plotCurve(bool checked)
{
QCheckBox *chk = (QCheckBox *)sender();
int btn=chk->objectName().mid(chk->objectName().lastIndexOf("_")+1).toInt()-1;
plot_curve[btn] = checked;
drawCurve();
}
void ModelEdit::on_T2ThrTrgChkB_toggled(bool checked)
{
g_model.t2throttle = checked;
updateSettings();
}
void ModelEdit::on_extendedLimitsChkB_toggled(bool checked)
{
g_model.extendedLimits = checked;
setLimitMinMax();
updateSettings();
}
void ModelEdit::on_thrwarnChkB_toggled(bool checked)
{
if (switchEditLock)
return;
g_model.disableThrottleWarning = checked;
updateSettings();
}
void ModelEdit::on_thrrevChkB_toggled(bool checked)
{
g_model.throttleReversed = checked;
updateSettings();
}
void ModelEdit::on_extendedTrimsChkB_toggled(bool checked)
{
g_model.extendedTrims = checked;
tabPhases();
updateSettings();
}
void ModelEdit::setLimitMinMax()
{
on_numChannelsSB_editingFinished();
on_numChannelsSB_2_editingFinished();
on_numChannelsSB_3_editingFinished();
int v = g_model.extendedLimits ? 125 : 100;
foreach(QSpinBox *sb, findChildren<QSpinBox *>(QRegExp("minSB_[0-9]+"))) {
sb->setMaximum(25);
sb->setMinimum(-v);
}
foreach(QSpinBox *sb, findChildren<QSpinBox *>(QRegExp("maxSB_[0-9]+"))) {
sb->setMaximum(v);
sb->setMinimum(-25);
}
}
void ModelEdit::safetySwitchesEdited()
{
for(int i=0; i<NUM_SAFETY_CHNOUT; i++) {
g_model.safetySw[i].swtch = RawSwitch(safetySwitchSwtch[i]->itemData(safetySwitchSwtch[i]->currentIndex()).toInt());
g_model.safetySw[i].val = safetySwitchValue[i]->value();
}
updateSettings();
}
void ModelEdit::on_templateList_doubleClicked(QModelIndex index)
{
QString text = ui->templateList->item(index.row())->text();
if (index.row()==13) {
uint64_t result=0xffffffff;
modelConfigDialog *mcw = new modelConfigDialog(radioData, &result, this);
mcw->exec();
if (result!=0xffffffff) {
applyNumericTemplate(result);
updateSettings();
tabMixes();
}
} else {
int res = QMessageBox::question(this,tr("Apply Template?"),tr("Apply template \"%1\"?").arg(text),QMessageBox::Yes | QMessageBox::No);
if(res!=QMessageBox::Yes) return;
applyTemplate(index.row());
updateSettings();
tabMixes();
}
}
MixData* ModelEdit::setDest(uint8_t dch)
{
uint8_t i = 0;
while ((g_model.mixData[i].destCh<=dch) && (g_model.mixData[i].destCh) && (i<GetEepromInterface()->getCapability(Mixes))) i++;
if(i==GetEepromInterface()->getCapability(Mixes)) return &g_model.mixData[0];
memmove(&g_model.mixData[i+1],&g_model.mixData[i],
(GetEepromInterface()->getCapability(Mixes)-(i+1))*sizeof(MixData) );
memset(&g_model.mixData[i],0,sizeof(MixData));
g_model.mixData[i].destCh = dch;
return &g_model.mixData[i];
}
void ModelEdit::clearExpos(bool ask)
{
if(ask) {
int res = QMessageBox::question(this,tr("Clear Expos?"),tr("Really clear all the expos?"),QMessageBox::Yes | QMessageBox::No);
if(res!=QMessageBox::Yes) return;
}
memset(g_model.expoData,0,sizeof(g_model.expoData)); //clear all expos
updateSettings();
tabExpos();
}
void ModelEdit::clearMixes(bool ask)
{
if(ask) {
int res = QMessageBox::question(this,tr("Clear Mixes?"),tr("Really clear all the mixes?"),QMessageBox::Yes | QMessageBox::No);
if(res!=QMessageBox::Yes) return;
}
memset(g_model.mixData,0,sizeof(g_model.mixData)); //clear all mixes
updateSettings();
tabMixes();
}
void ModelEdit::clearCurves(bool ask)
{
if(ask) {
int res = QMessageBox::question(this,tr("Clear Curves?"),tr("Really clear all the curves?"),QMessageBox::Yes | QMessageBox::No);
if(res!=QMessageBox::Yes) return;
}
curvesLock=true;
if (!GetEepromInterface()->getCapability(CustomCurves)){
ui->curvetype_CB->setDisabled(true);
int count=0;
for (int j=0; j< GetEepromInterface()->getCapability(NumCurves3); j++) {
g_model.curves[count].count=3;
g_model.curves[count].custom=false;
memset(g_model.curves[j].name,0,sizeof(g_model.curves[j].name));
for (int i=0; i<17; i++) {
g_model.curves[count].points[i].x=0;
g_model.curves[count].points[i].y=0;
}
count++;
}
for (int j=0; j< GetEepromInterface()->getCapability(NumCurves5); j++) {
g_model.curves[count].count=5;
g_model.curves[count].custom=false;
memset(g_model.curves[j].name,0,sizeof(g_model.curves[j].name));
for (int i=0; i<17; i++) {
g_model.curves[count].points[i].x=0;
g_model.curves[count].points[i].y=0;
}
count++;
}
for (int j=0; j< GetEepromInterface()->getCapability(NumCurves9); j++) {
g_model.curves[count].count=9;
g_model.curves[count].custom=false;
memset(g_model.curves[j].name,0,sizeof(g_model.curves[j].name));
for (int i=0; i<17; i++) {
g_model.curves[count].points[i].x=0;
g_model.curves[count].points[i].y=0;
}
count++;
}
for (int j=count; j<16; j++) {
g_model.curves[j].count=5;
g_model.curves[j].custom=false;
memset(g_model.curves[j].name,0,sizeof(g_model.curves[j].name));
for (int i=0; i<17; i++) {
g_model.curves[j].points[i].x=0;
g_model.curves[j].points[i].y=0;
}
}
} else {
for (int j=0; j<16; j++) {
g_model.curves[j].count=5;
g_model.curves[j].custom=false;
memset(g_model.curves[j].name,0,sizeof(g_model.curves[j].name));
for (int i=0; i<17; i++) {
g_model.curves[j].points[i].x=0;
g_model.curves[j].points[i].y=0;
}
}
}
for (int i=0; i<17; i++) {
spnx[i]->setMinimum(-100);
spnx[i]->setMaximum(100);
spnx[i]->setValue(0);
spny[i]->setValue(0);
}
currentCurve=0;
curvesLock=false;
if (GetEepromInterface()->getCapability(NumCurves3)>0) {
ui->curvetype_CB->setCurrentIndex(0);
} else {
ui->curvetype_CB->setCurrentIndex(2);
}
ui->cname_LE->clear();
updateSettings();
drawCurve();
}
void ModelEdit::setCurve(uint8_t c, int8_t ar[])
{
int len=sizeof(ar)/sizeof(int8_t);
if (GetEepromInterface()->getCapability(CustomCurves)) {
if (GetEepromInterface()->getCapability(NumCurves)>c) {
if (len<9) {
g_model.curves[c].count=5;
g_model.curves[c].custom=false;
for (int i=0; i< 5; i++) {
g_model.curves[c].points[i].y=ar[i];
}
} else {
g_model.curves[c].count=5;
g_model.curves[c].custom=false;
for (int i=0; i< 5; i++) {
g_model.curves[c].points[i].y=ar[i];
}
}
}
} else {
if (len<9) {
g_model.curves[c].count=5;
g_model.curves[c].custom=false;
for (int i=0; i< 5; i++) {
g_model.curves[c].points[i].y=ar[i];
}
} else {
g_model.curves[c+8].count=5;
g_model.curves[c+8].custom=false;
for (int i=0; i< 5; i++) {
g_model.curves[c+8].points[i].y=ar[i];
}
}
}
}
void ModelEdit::setSwitch(unsigned int idx, unsigned int func, int v1, int v2)
{
g_model.customSw[idx-1].func = func;
g_model.customSw[idx-1].val1 = v1;
g_model.customSw[idx-1].val2 = v2;
}
void ModelEdit::applyNumericTemplate(uint64_t tpl)
{
clearCurves(false);
clearExpos(false);
clearMixes(false);
int8_t heli_ar1[] = {-100, -20, 30, 70, 90};
int8_t heli_ar2[] = {80, 70, 60, 70, 100};
int8_t heli_ar3[] = {100, 90, 80, 90, 100};
int8_t heli_ar4[] = {-30, -15, 0, 50, 100};
int8_t heli_ar5[] = {-100, -50, 0, 50, 100};
bool rx[10];
for (int i=0; i<10 ; i++) {
rx[i]=false;
}
int thrsw=GetEepromInterface()->getCapability(GetThrSwitch);
MixData *md = &g_model.mixData[0];
uint8_t spo2ch=(tpl & 0x0F);
tpl>>=4;
uint8_t spo1ch=(tpl & 0x0F);
tpl>>=4;
uint8_t fla2ch=(tpl & 0x0F);
tpl>>=4;
uint8_t fla1ch=(tpl & 0x0F);
tpl>>=4;
uint8_t rud2ch=(tpl & 0x0F);
tpl>>=4;
uint8_t ele2ch=(tpl & 0x0F);
tpl>>=4;
uint8_t ail2ch=(tpl & 0x0F);
tpl>>=4;
uint8_t chstyle=(tpl & 0x03);
tpl>>=2;
uint8_t gyro=(tpl & 0x03);
tpl>>=2;
uint8_t tailtype=(tpl & 0x03);
tpl>>=2;
uint8_t swashtype=(tpl & 0x07);
tpl>>=3;
uint8_t ruddertype=(tpl & 0x03);
tpl>>=2;
uint8_t spoilertype=(tpl & 0x3);
tpl>>=2;
uint8_t flaptype=(tpl & 0x03);
tpl>>=2;
uint8_t ailerontype=(tpl & 0x03);
tpl>>=2;
uint8_t enginetype=(tpl & 0x03);
tpl>>=2;
uint8_t modeltype=(tpl & 0x03);
#define ICC(x) icc[(x)-1]
uint8_t icc[4] = {0};
for(uint8_t i=1; i<=4; i++) //generate inverse array
for(uint8_t j=1; j<=4; j++) if(CC(i)==j) icc[j-1]=i;
int ailerons;
int flaps;
int throttle;
int spoilers;
int elevators;
int rudders;
int sign;
uint8_t rxch;
switch (modeltype) {
case 0:
ailerons=ailerontype;
flaps=flaptype;
throttle=1;
switch (tailtype) {
case 0:
case 1:
rudders=1;
elevators=1;
break;
case 2:
rudders=1;
elevators=2;
break;
}
rxch=ICC(STK_RUD);
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("RUD").toAscii().data(),6);
if (tailtype==1) {
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=-100; md->swtch=RawSwitch();strncpy(md->name, tr("ELE").toAscii().data(),6);
}
rx[rxch-1]=true;
rxch=ICC(STK_ELE);
if (tailtype==1) {
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("RUD").toAscii().data(),6);
}
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("ELE").toAscii().data(),6);
rx[rxch-1]=true;
rxch=ICC(STK_THR);
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("THR").toAscii().data(),6);
rx[rxch-1]=true;
if (ail2ch > 0) {
rx[ail2ch-1]=true;
}
if (ele2ch > 0) {
rx[ele2ch-1]=true;
}
if (fla1ch > 0) {
rx[fla1ch-1]=true;
}
if (fla2ch > 0) {
rx[fla2ch-1]=true;
}
if (ailerons>0) {
rxch=ICC(STK_AIL);
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("AIL").toAscii().data(),6);
rx[rxch-1]=true;
}
if (ailerons>1) {
if (ail2ch==0) {
for (int j=0; j<10 ; j++) {
if (!rx[j]) {
md=setDest(j+1); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("AIL2").toAscii().data(),6);
rx[j]=true;
break;
}
}
} else {
md=setDest(ail2ch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("AIL2").toAscii().data(),6);
}
}
if (elevators>1) {
if (ele2ch==0) {
for (int j=0; j<10 ; j++) {
if (!rx[j]) {
md=setDest(j+1); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=-100; md->swtch=RawSwitch();;strncpy(md->name, tr("ELE2").toAscii().data(),6);
rx[j]=true;
break;
}
}
}else{
md=setDest(ele2ch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=-100; md->swtch=RawSwitch();;strncpy(md->name, tr("ELE2").toAscii().data(),6);
}
}
if (flaps>0) {
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_AIL);strncpy(md->name, tr("FLAPS").toAscii().data(),6); md->speedUp=4; md->speedDown=4;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_AIL);strncpy(md->name, tr("FLAPS").toAscii().data(),6); md->speedUp=4; md->speedDown=4;
}
sign=-1;
for (uint8_t i=0; i< flaps; i++) {
sign*=-1;
int index;
if (i==0) {
index=fla1ch;
} else {
index=fla2ch;
}
if (index==0) {
for (int j=0; j<10 ; j++) {
if (!rx[j]) {
md=setDest(j+1); md->srcRaw=RawSource(SOURCE_TYPE_CH, 10); md->weight=100*sign; md->sOffset=0; md->swtch=RawSwitch();strncpy(md->name, tr("FLAP%1").arg(i+1).toAscii().data(),6);
rx[j]=true;
break;
}
}
} else {
md=setDest(index); md->srcRaw=RawSource(SOURCE_TYPE_CH, 10); md->weight=100*sign; md->sOffset=0; md->swtch=RawSwitch();strncpy(md->name, tr("FLAP%1").arg(i+1).toAscii().data(),6);
}
}
break;
case 1:
setCurve(CURVE5(1),heli_ar1);
setCurve(CURVE5(2),heli_ar2);
setCurve(CURVE5(3),heli_ar3);
setCurve(CURVE5(4),heli_ar4);
setCurve(CURVE5(5),heli_ar5);
setCurve(CURVE5(6),heli_ar5);
switch (swashtype) {
case 0:
g_model.swashRingData.type = HELI_SWASH_TYPE_90;
break;
case 1:
g_model.swashRingData.type = HELI_SWASH_TYPE_120;
break;
case 2:
g_model.swashRingData.type = HELI_SWASH_TYPE_120X;
break;
case 3:
g_model.swashRingData.type = HELI_SWASH_TYPE_140;
break;
case 4:
g_model.swashRingData.type = HELI_SWASH_TYPE_NONE;
break;
}
g_model.swashRingData.collectiveSource = RawSource(SOURCE_TYPE_CH, 10);
if (chstyle==0) {
if (swashtype!=4) {
md=setDest(1); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 0); md->weight= 100; md->swtch=RawSwitch();strncpy(md->name, tr("ELE").toAscii().data(),6);
md=setDest(2); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 1); md->weight= 100; md->swtch=RawSwitch();strncpy(md->name, tr("AIL").toAscii().data(),6);
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 2); md->weight= 100; md->swtch=RawSwitch();strncpy(md->name, tr("PITCH").toAscii().data(),6);
} else {
md=setDest(1); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight= 100; md->swtch=RawSwitch();strncpy(md->name, tr("ELE").toAscii().data(),6);
md=setDest(2); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight= 100; md->swtch=RawSwitch();strncpy(md->name, tr("AIL").toAscii().data(),6);
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_CH, 10); md->weight= 100; md->swtch=RawSwitch();strncpy(md->name, tr("PITCH").toAscii().data(),6);
}
md=setDest(4); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("RUD").toAscii().data(),6);
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID0); md->curve=CV(1); md->carryTrim=TRIM_OFF;
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID1); md->curve=CV(2); md->carryTrim=TRIM_OFF;
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID2); md->curve=CV(3); md->carryTrim=TRIM_OFF;
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,thrsw); md->mltpx=MLTPX_REP;
switch (gyro) {
case 1:
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=30; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_GEA);strncpy(md->name, tr("GYRO").toAscii().data(),6);
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-30; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_GEA);strncpy(md->name, tr("GYRO").toAscii().data(),6);
break;
case 2:
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight= 50; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_GEA); md->sOffset=100;strncpy(md->name, tr("GYRO").toAscii().data(),6);
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight=-50; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_GEA); md->sOffset=100;strncpy(md->name, tr("GYRO").toAscii().data(),6);
break;
}
} else {
if (swashtype!=4) {
md=setDest(1); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 1); md->weight= 100; md->swtch=RawSwitch();strncpy(md->name, tr("AIL").toAscii().data(),6);
md=setDest(2); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 0); md->weight= 100; md->swtch=RawSwitch();strncpy(md->name, tr("ELE").toAscii().data(),6);
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 2); md->weight= 100; md->swtch=RawSwitch();strncpy(md->name, tr("PITCH").toAscii().data(),6);
} else {
md=setDest(1); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight= 100; md->swtch=RawSwitch();strncpy(md->name, tr("AIL").toAscii().data(),6);
md=setDest(2); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight= 100; md->swtch=RawSwitch();strncpy(md->name, tr("ELE").toAscii().data(),6);
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_CH, 10); md->weight= 100; md->swtch=RawSwitch();strncpy(md->name, tr("PITCH").toAscii().data(),6);
}
md=setDest(4); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("RUD").toAscii().data(),6);
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID0); md->curve=CV(1); md->carryTrim=TRIM_OFF;
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID1); md->curve=CV(2); md->carryTrim=TRIM_OFF;
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID2); md->curve=CV(3); md->carryTrim=TRIM_OFF;
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,thrsw); md->mltpx=MLTPX_REP;
switch (gyro) {
case 1:
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=30; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_GEA);strncpy(md->name, tr("GYRO").toAscii().data(),6);
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-30; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_GEA);strncpy(md->name, tr("GYRO").toAscii().data(),6);
break;
case 2:
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight= 50; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_GEA); md->sOffset=100;strncpy(md->name, tr("GYRO").toAscii().data(),6);
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight=-50; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_GEA); md->sOffset=100;strncpy(md->name, tr("GYRO").toAscii().data(),6);
break;
}
}
// collective
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID0); md->curve=CV(4); md->carryTrim=TRIM_OFF;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID1); md->curve=CV(5); md->carryTrim=TRIM_OFF;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID2); md->curve=CV(6); md->carryTrim=TRIM_OFF;
break;
case 2:
ailerons=ailerontype;
flaps=flaptype;
spoilers=spoilertype;
throttle=enginetype;
switch (tailtype) {
case 0:
case 1:
rudders=1;
elevators=1;
break;
case 2:
rudders=1;
elevators=2;
break;
}
if (throttle==1) {
rxch=ICC(STK_THR);
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("THR").toAscii().data(),6);
rx[rxch-1]=true;
}
rxch=ICC(STK_RUD);
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("RUD").toAscii().data(),6);
if (tailtype==1) {
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=-100; md->swtch=RawSwitch();strncpy(md->name, tr("RUD").toAscii().data(),6);
}
rx[rxch-1]=true;
rxch=ICC(STK_ELE);
if (tailtype==1) {
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=-100; md->swtch=RawSwitch();strncpy(md->name, tr("ELE").toAscii().data(),6);
}
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("ELE").toAscii().data(),6);
rx[rxch-1]=true;
if (ail2ch > 0) {
rx[ail2ch-1]=true;
}
if (ele2ch > 0) {
rx[ele2ch-1]=true;
}
if (fla1ch > 0) {
rx[fla1ch-1]=true;
}
if (fla2ch > 0) {
rx[fla2ch-1]=true;
}
if (spo1ch > 0) {
rx[spo1ch-1]=true;
}
if (spo2ch > 0) {
rx[spo2ch-1]=true;
}
if (ailerons>0) {
rxch=ICC(STK_AIL);
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("AIL").toAscii().data(),6);
rx[rxch-1]=true;
}
if (ailerons>1) {
if (ail2ch==0) {
for (int j=0; j<10 ; j++) {
if (!rx[j]) {
md=setDest(j+1); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("AIL2").toAscii().data(),6);
rx[j]=true;
break;
}
}
} else {
md=setDest(ail2ch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("AIL2").toAscii().data(),6);
}
}
if (elevators>1) {
if (ele2ch==0) {
for (int j=0; j<10 ; j++) {
if (!rx[j]) {
md=setDest(j+1); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=-100; md->swtch=RawSwitch();strncpy(md->name, tr("ELE2").toAscii().data(),6);
rx[j]=true;
break;
}
}
} else {
md=setDest(ele2ch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=-100; md->swtch=RawSwitch();strncpy(md->name, tr("ELE2").toAscii().data(),6);
}
}
if (flaps>0) {
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_AIL);strncpy(md->name, tr("FLAPS").toAscii().data(),6);md->speedUp=4; md->speedDown=4;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_AIL);strncpy(md->name, tr("FLAPS").toAscii().data(),6);md->speedUp=4; md->speedDown=4;
}
sign=-1;
for (uint8_t i=0; i< flaps; i++) {
sign*=-1;
int index;
if (i==0) {
index=fla1ch;
} else {
index=fla2ch;
}
if (index==0) {
for (int j=0; j<10 ; j++) {
if (!rx[j]) {
md=setDest(j+1); md->srcRaw=RawSource(SOURCE_TYPE_CH, 10); md->weight=100*sign; md->sOffset=0; md->swtch=RawSwitch();strncpy(md->name, tr("FLAP%1").arg(i+1).toAscii().data(),6);
rx[j]=true;
break;
}
}
} else {
md=setDest(index); md->srcRaw=RawSource(SOURCE_TYPE_CH, 10); md->weight=100*sign; md->sOffset=0; md->swtch=RawSwitch();strncpy(md->name, tr("FLAP%1").arg(i+1).toAscii().data(),6);
}
}
if (spoilers>0) {
md=setDest(12); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_GEA);strncpy(md->name, tr("SPOIL").toAscii().data(),6); md->speedUp=4;;md->speedDown=4;
md=setDest(12); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_GEA);strncpy(md->name, tr("SPOIL").toAscii().data(),6);md->speedUp=4;md->speedDown=4;
}
sign=-1;
for (uint8_t i=0; i< spoilers; i++) {
sign*=-1;
int index;
if (i==0) {
index=spo1ch;
} else {
index=spo2ch;
}
if (index==0) {
for (int j=0; j<10 ; j++) {
if (!rx[j]) {
md=setDest(j+1); md->srcRaw=RawSource(SOURCE_TYPE_CH, 11); md->weight=100*sign; md->sOffset=0; md->swtch=RawSwitch();strncpy(md->name, tr("SPOIL%1").arg(i+1).toAscii().data(),6);
rx[j]=true;
break;
}
}
} else {
md=setDest(index); md->srcRaw=RawSource(SOURCE_TYPE_CH, 11); md->weight=100*sign; md->sOffset=0; md->swtch=RawSwitch();strncpy(md->name, tr("SPOIL%1").arg(i+1).toAscii().data(),6);
}
}
break;
case 3:
flaps=flaptype;
throttle=enginetype;
rudders=ruddertype;
if (throttle==1) {
rxch=ICC(STK_THR);
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("THR").toAscii().data(),6);
rx[rxch-1]=true;
}
rxch=ICC(STK_ELE);
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("ELE").toAscii().data(),6);
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("ELE").toAscii().data(),6);
rx[rxch-1]=true;
rxch=ICC(STK_AIL);
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=-100; md->swtch=RawSwitch();strncpy(md->name, tr("AIL").toAscii().data(),6);
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("AIL").toAscii().data(),6);
rx[rxch-1]=true;
if (rudders>0) {
rxch=ICC(STK_RUD);
md=setDest(rxch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch();strncpy(md->name, tr("RUD").toAscii().data(),6);
rx[rxch-1]=true;
}
if (rud2ch > 0) {
rx[rud2ch-1]=true;
}
if (fla1ch > 0) {
rx[fla1ch-1]=true;
}
if (fla2ch > 0) {
rx[fla2ch-1]=true;
}
if (rudders>1) {
if (rud2ch==0) {
for (int j=0; j<10 ; j++) {
if (!rx[j]) {
md=setDest(j+1); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=-100; md->swtch=RawSwitch();strncpy(md->name, tr("RUD2").toAscii().data(),6);
rx[j]=true;
break;
}
}
} else {
md=setDest(rud2ch); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=-100; md->swtch=RawSwitch();strncpy(md->name, tr("RUD2").toAscii().data(),6);
}
}
if (flaps>0) {
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_AIL);strncpy(md->name, tr("FLAPS").toAscii().data(),6); md->sOffset=0; md->speedUp=4;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_AIL);strncpy(md->name, tr("FLAPS").toAscii().data(),6); md->sOffset=0; md->speedUp=4;
}
sign=-1;
for (uint8_t i=0; i< flaps; i++) {
sign*=-1;
int index;
if (i==0) {
index=fla1ch;
} else {
index=fla2ch;
}
if (index==0) {
for (int j=0; j<10 ; j++) {
if (!rx[j]) {
md=setDest(j+1); md->srcRaw=RawSource(SOURCE_TYPE_CH, 10); md->weight=100*sign; md->sOffset=0; md->speedUp=4; md->speedDown=4; md->swtch=RawSwitch();strncpy(md->name, tr("FLAP%1").arg(i+1).toAscii().data(),6);
rx[j]=true;
break;
}
}
} else {
md=setDest(index); md->srcRaw=RawSource(SOURCE_TYPE_CH, 10); md->weight=100*sign; md->sOffset=0; md->speedUp=4; md->speedDown=4; md->swtch=RawSwitch();strncpy(md->name, tr("FLAP%1").arg(i+1).toAscii().data(),6);
}
}
break;
}
updateHeliTab();
updateCurvesTab();
if (modeltype==1 && swashtype!=4) {
ui->tabWidget->setCurrentIndex(1);
} else {
ui->tabWidget->setCurrentIndex(4);
}
resizeEvent();
}
void ModelEdit::applyTemplate(uint8_t idx)
{
int8_t heli_ar1[] = {-100, -20, 30, 70, 90};
int8_t heli_ar2[] = {80, 70, 60, 70, 100};
int8_t heli_ar3[] = {100, 90, 80, 90, 100};
int8_t heli_ar4[] = {-30, -15, 0, 50, 100};
int8_t heli_ar5[] = {-100, -50, 0, 50, 100};
int thrsw=GetEepromInterface()->getCapability(GetThrSwitch);
MixData *md = &g_model.mixData[0];
//CC(STK) -> vSTK
//ICC(vSTK) -> STK
#define ICC(x) icc[(x)-1]
uint8_t icc[4] = {0};
for(uint8_t i=1; i<=4; i++) //generate inverse array
for(uint8_t j=1; j<=4; j++) if(CC(i)==j) icc[j-1]=i;
uint8_t j = 0;
//Simple 4-Ch
if(idx==j++) {
if (md->destCh)
clearMixes();
md=setDest(ICC(STK_RUD)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch();
md=setDest(ICC(STK_ELE)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=100; md->swtch=RawSwitch();
md=setDest(ICC(STK_THR)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch();
md=setDest(ICC(STK_AIL)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight=100; md->swtch=RawSwitch();
}
//T-Cut
if(idx==j++) {
md=setDest(ICC(STK_THR)); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,thrsw); md->mltpx=MLTPX_REP;
}
//sticky t-cut
if(idx==j++) {
md=setDest(ICC(STK_THR)); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_VIRTUAL, 12); md->mltpx=MLTPX_REP;
md=setDest(14); md->srcRaw=RawSource(SOURCE_TYPE_CH, 13); md->weight= 100; md->swtch=RawSwitch();
md=setDest(14); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_VIRTUAL, 11); md->mltpx=MLTPX_REP;
md=setDest(14); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,thrsw); md->mltpx=MLTPX_REP;
setSwitch(0xB, CS_FN_VNEG, RawSource(SOURCE_TYPE_STICK, 2).toValue(), -99);
setSwitch(0xC, CS_FN_VPOS, RawSource(SOURCE_TYPE_CH, 13).toValue(), 0);
updateSwitchesTab();
}
//V-Tail
if(idx==j++) {
clearMixes();
md=setDest(ICC(STK_THR)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch();
md=setDest(ICC(STK_AIL)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight=100; md->swtch=RawSwitch();
md=setDest(ICC(STK_RUD)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight= 100; md->swtch=RawSwitch();
md=setDest(ICC(STK_RUD)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=-100; md->swtch=RawSwitch();
md=setDest(ICC(STK_ELE)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight= 100; md->swtch=RawSwitch();
md=setDest(ICC(STK_ELE)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight= 100; md->swtch=RawSwitch();
}
//Elevon\\Delta
if(idx==j++) {
clearMixes();
md=setDest(ICC(STK_THR)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch();
md=setDest(ICC(STK_RUD)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch();
md=setDest(ICC(STK_ELE)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight= 100; md->swtch=RawSwitch();
md=setDest(ICC(STK_ELE)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight= 100; md->swtch=RawSwitch();
md=setDest(ICC(STK_AIL)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=-100; md->swtch=RawSwitch();
md=setDest(ICC(STK_AIL)); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight=100; md->swtch=RawSwitch();
}
//Heli Setup
if(idx==j++) {
clearMixes(); //This time we want a clean slate
clearCurves();
// Set up Mixes
// 3 cyclic channels
md=setDest(1); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 0); md->weight= 100; md->swtch=RawSwitch();
md=setDest(2); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 1); md->weight= 100; md->swtch=RawSwitch();
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 2); md->weight= 100; md->swtch=RawSwitch();
// rudder
md=setDest(4); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch();
// throttle
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID0); md->curve=CV(1); md->carryTrim=TRIM_OFF;
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID1); md->curve=CV(2); md->carryTrim=TRIM_OFF;
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID2); md->curve=CV(3); md->carryTrim=TRIM_OFF;
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,thrsw); md->mltpx=MLTPX_REP;
// gyro gain
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=30; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_GEA);
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-30; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_GEA);
// collective
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID0); md->curve=CV(4); md->carryTrim=TRIM_OFF;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID1); md->curve=CV(5); md->carryTrim=TRIM_OFF;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID2); md->curve=CV(6); md->carryTrim=TRIM_OFF;
g_model.swashRingData.type = HELI_SWASH_TYPE_120;
g_model.swashRingData.collectiveSource = RawSource(SOURCE_TYPE_CH, 10);
// set up Curves
setCurve(CURVE5(1),heli_ar1);
setCurve(CURVE5(2),heli_ar2);
setCurve(CURVE5(3),heli_ar3);
setCurve(CURVE5(4),heli_ar4);
setCurve(CURVE5(5),heli_ar5);
setCurve(CURVE5(6),heli_ar5);
// make sure curves are redrawn
updateHeliTab();
updateCurvesTab();
resizeEvent();
}
//Heli Setup gyro gain control
if(idx==j++) {
clearMixes(); //This time we want a clean slate
clearCurves();
// Set up Mixes
// 3 cyclic channels
md=setDest(1); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 0); md->weight= 100; md->swtch=RawSwitch();
md=setDest(2); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 1); md->weight= 100; md->swtch=RawSwitch();
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 2); md->weight= 100; md->swtch=RawSwitch();
// rudder
md=setDest(4); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch();
// throttle
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID0); md->curve=CV(1); md->carryTrim=TRIM_OFF;
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID1); md->curve=CV(2); md->carryTrim=TRIM_OFF;
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID2); md->curve=CV(3); md->carryTrim=TRIM_OFF;
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,thrsw); md->mltpx=MLTPX_REP;
// gyro gain
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight= 50; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_GEA); md->sOffset=100;
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight=-50; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_GEA); md->sOffset=100;
// collective
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID0); md->curve=CV(4); md->carryTrim=TRIM_OFF;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID1); md->curve=CV(5); md->carryTrim=TRIM_OFF;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID2); md->curve=CV(6); md->carryTrim=TRIM_OFF;
g_model.swashRingData.type = HELI_SWASH_TYPE_120;
g_model.swashRingData.collectiveSource = RawSource(SOURCE_TYPE_CH, 10);
// set up Curves
setCurve(CURVE5(1),heli_ar1);
setCurve(CURVE5(2),heli_ar2);
setCurve(CURVE5(3),heli_ar3);
setCurve(CURVE5(4),heli_ar4);
setCurve(CURVE5(5),heli_ar5);
setCurve(CURVE5(6),heli_ar5);
// make sure curves are redrawn
updateHeliTab();
updateCurvesTab();
resizeEvent();
}
// gyro gain control
if(idx==j++) {
int res = QMessageBox::question(this,tr("Clear Mixes?"),tr("Really clear existing mixes on CH6?"),QMessageBox::Yes | QMessageBox::No);
if(res!=QMessageBox::Yes) return;
// first clear mix on ch6
bool found=true;
while (found) {
found=false;
for (int i=0; i< GetEepromInterface()->getCapability(Mixes); i++) {
if (g_model.mixData[i].destCh==6) {
gm_deleteMix(i);
found=true;
break;
}
}
}
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight= 50; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_GEA); md->sOffset=100;
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight=-50; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_GEA); md->sOffset=100;
}
//Heli Setup futaba style
if(idx==j++) {
clearMixes(); //This time we want a clean slate
clearCurves();
// Set up Mixes
// 3 cyclic channels
md=setDest(1); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 1); md->weight= 100; md->swtch=RawSwitch();
md=setDest(2); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 0); md->weight= 100; md->swtch=RawSwitch();
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 2); md->weight= 100; md->swtch=RawSwitch();
// rudder
md=setDest(4); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch();
// throttle
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID0); md->curve=CV(1); md->carryTrim=TRIM_OFF;
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID1); md->curve=CV(2); md->carryTrim=TRIM_OFF;
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID2); md->curve=CV(3); md->carryTrim=TRIM_OFF;
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,thrsw); md->mltpx=MLTPX_REP;
// gyro gain
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=30; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_GEA);
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-30; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_GEA);
// collective
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID0); md->curve=CV(4); md->carryTrim=TRIM_OFF;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID1); md->curve=CV(5); md->carryTrim=TRIM_OFF;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID2); md->curve=CV(6); md->carryTrim=TRIM_OFF;
g_model.swashRingData.type = HELI_SWASH_TYPE_120;
g_model.swashRingData.collectiveSource = RawSource(SOURCE_TYPE_CH, 10);
// set up Curves
setCurve(CURVE5(1),heli_ar1);
setCurve(CURVE5(2),heli_ar2);
setCurve(CURVE5(3),heli_ar3);
setCurve(CURVE5(4),heli_ar4);
setCurve(CURVE5(5),heli_ar5);
setCurve(CURVE5(6),heli_ar5);
// make sure curves are redrawn
updateHeliTab();
updateCurvesTab();
resizeEvent();
}
// Heli setup futaba style with gyro gain control
if(idx==j++) {
clearMixes(); //This time we want a clean slate
clearCurves();
// Set up Mixes
// 3 cyclic channels
md=setDest(1); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 1); md->weight= 100; md->swtch=RawSwitch();
md=setDest(2); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 0); md->weight= 100; md->swtch=RawSwitch();
md=setDest(6); md->srcRaw=RawSource(SOURCE_TYPE_CYC, 2); md->weight= 100; md->swtch=RawSwitch();
// rudder
md=setDest(4); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch();
// throttle
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID0); md->curve=CV(1); md->carryTrim=TRIM_OFF;
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID1); md->curve=CV(2); md->carryTrim=TRIM_OFF;
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight= 100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID2); md->curve=CV(3); md->carryTrim=TRIM_OFF;
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,thrsw); md->mltpx=MLTPX_REP;
// gyro gain
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight= 50; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_GEA); md->sOffset=100;
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight=-50; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_GEA); md->sOffset=100;
// collective
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID0); md->curve=CV(4); md->carryTrim=TRIM_OFF;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID1); md->curve=CV(5); md->carryTrim=TRIM_OFF;
md=setDest(11); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_ID2); md->curve=CV(6); md->carryTrim=TRIM_OFF;
g_model.swashRingData.type = HELI_SWASH_TYPE_120;
g_model.swashRingData.collectiveSource = RawSource(SOURCE_TYPE_CH, 10);
// set up Curves
setCurve(CURVE5(1),heli_ar1);
setCurve(CURVE5(2),heli_ar2);
setCurve(CURVE5(3),heli_ar3);
setCurve(CURVE5(4),heli_ar4);
setCurve(CURVE5(5),heli_ar5);
setCurve(CURVE5(6),heli_ar5);
// make sure curves are redrawn
updateHeliTab();
updateCurvesTab();
resizeEvent();
}
// gyro gain control futaba style
if(idx==j++) {
int res = QMessageBox::question(this,tr("Clear Mixes?"),tr("Really clear existing mixes on CH5?"),QMessageBox::Yes | QMessageBox::No);
if(res!=QMessageBox::Yes) return;
// first clear mix on ch6
bool found=true;
while (found) {
found=false;
for (int i=0; i< GetEepromInterface()->getCapability(Mixes); i++) {
if (g_model.mixData[i].destCh==5) {
gm_deleteMix(i);
found=true;
break;
}
}
}
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight= 50; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,-DSW_GEA); md->sOffset=100;
md=setDest(5); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 5); md->weight=-50; md->swtch=RawSwitch(SWITCH_TYPE_SWITCH,DSW_GEA); md->sOffset=100;
}
//Servo Test
if(idx==j++) {
md=setDest(15); md->srcRaw=RawSource(SOURCE_TYPE_CH, 15); md->weight= 100; md->speedUp = 8; md->speedDown = 8; md->swtch=RawSwitch();
md=setDest(16); md->srcRaw=RawSource(SOURCE_TYPE_CUSTOM_SWITCH, 0); md->weight= 110; md->swtch=RawSwitch();
md=setDest(16); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight=-110; md->swtch=RawSwitch(SWITCH_TYPE_VIRTUAL, 2); md->mltpx=MLTPX_REP;
md=setDest(16); md->srcRaw=RawSource(SOURCE_TYPE_MAX); md->weight= 110; md->swtch=RawSwitch(SWITCH_TYPE_VIRTUAL, 3); md->mltpx=MLTPX_REP;
setSwitch(1, CS_FN_LESS, RawSource(SOURCE_TYPE_CH, 14).toValue(), RawSource(SOURCE_TYPE_CH, 15).toValue());
setSwitch(2, CS_FN_VPOS, RawSource(SOURCE_TYPE_CH, 14).toValue(), 105);
setSwitch(3, CS_FN_VNEG, RawSource(SOURCE_TYPE_CH, 14).toValue(), -105);
// redraw switches tab
updateSwitchesTab();
}
//MultiCopter
if(idx==j++) {
if (md->destCh)
clearMixes();
md=setDest(1); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 3); md->weight=50; md->swtch=RawSwitch(); //CH1 AIL
md=setDest(2); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 1); md->weight=-50; md->swtch=RawSwitch(); //CH2 ELE
md=setDest(3); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 2); md->weight=100; md->swtch=RawSwitch(); //CH3 THR
md=setDest(4); md->srcRaw=RawSource(SOURCE_TYPE_STICK, 0); md->weight=100; md->swtch=RawSwitch(); //CH4 RUD
}
}
void ModelEdit::ControlCurveSignal(bool flag)
{
foreach(QSpinBox *sb, findChildren<QSpinBox *>(QRegExp("curvePt[0-9]+"))) {
sb->blockSignals(flag);
}
}
void ModelEdit::shrink() {
#if defined __APPLE__
QSettings settings("companion9x", "companion9x");
QPoint pos = settings.value("mepos", QPoint(0, 0)).toPoint();
QSize size = settings.value("mesize", QSize(800, 625)).toSize();
move(pos);
resize(size);
# else
const int height = QApplication::desktop()->height();
QSettings settings("companion9x", "companion9x");
QPoint pos = settings.value("mepos", QPoint(100, 100)).toPoint();
QSize size = settings.value("mesize", QSize(800, 625)).toSize();
if (size.height() < height) {
move(pos);
resize(size);
} else {
resize(0,0);
}
#endif
ui->curvePreview->repaint();
}
void ModelEdit::on_cname_LE_editingFinished() {
if (GetEepromInterface()->getCapability(HasCvNames)) {
int i=0;
for (i=0; i<ui->cname_LE->text().toAscii().length(); i++) {
g_model.curves[currentCurve].name[i]=ui->cname_LE->text().toAscii().at(i);
}
g_model.curves[currentCurve].name[i]=0;
}
updateSettings();
}
void ModelEdit::on_curvetype_CB_currentIndexChanged(int index) {
if (curvesLock)
return;
int numcurves=GetEepromInterface()->getCapability(NumCurves);
if (numcurves==0) {
numcurves=16;
}
int numpoint[]={3,3,5,5,9,9,17,17};
bool custom[]={false,true,false,true,false,true,false,true};
int currpoints=g_model.curves[currentCurve].count;
bool currcustom=g_model.curves[currentCurve].custom;
curvesLock=true;
int totalpoints=0;
for (int i=0; i< numcurves; i++) {
if (i!=currentCurve) {
totalpoints+=g_model.curves[i].count;
if (g_model.curves[i].custom) {
totalpoints+=g_model.curves[i].count-2;
}
}
}
totalpoints+=numpoint[index];
if (currcustom) {
totalpoints+=numpoint[index]-2;
}
int fwpoints=GetEepromInterface()->getCapability(NumCurvePoints);
if (fwpoints!=0) {
if (fwpoints<totalpoints) {
QMessageBox::warning(this, "Companion", tr("Not enough free points in eeprom to store the curve."));
int oldindex=0;
if (currpoints==3) {
oldindex=0;
} else if (currpoints==5) {
oldindex=2;
} else if (currpoints==9) {
oldindex=4;
} else if (currpoints==17) {
oldindex=6;
}
if (currcustom) {
index++;
}
ui->curvetype_CB->setCurrentIndex(oldindex);
curvesLock=false;
return;
}
}
// let's be sure that for standard curves X values are set correctly.
if (!currcustom) {
for (int i=0; i< currpoints; i++) {
spnx[i]->setMinimum(-100);
spnx[i]->setMaximum(100);
spnx[i]->setValue(-100+((200*i)/(currpoints-1)));
}
}
if (numpoint[index]==currpoints) {
for (int i=0; i< currpoints; i++) {
spnx[i]->setMinimum(-100);
spnx[i]->setMaximum(100);
spnx[i]->setValue(-100+((200*i)/(currpoints-1)));
}
for (int i=currpoints; i< 17; i++) {
spnx[i]->setMinimum(-100);
spnx[i]->setMaximum(100);
spnx[i]->setValue(0);
spny[i]->setValue(0);
}
} else if (numpoint[index]>currpoints) {
for (int i=0; i< 17; i++) {
g_model.curves[currentCurve].points[i].x=spnx[i]->value();
g_model.curves[currentCurve].points[i].y=spny[i]->value();
spnx[i]->setMinimum(-100);
spnx[i]->setMaximum(100);
}
int currintervals=currpoints-1;
int diffpoints=numpoint[index]-currpoints;
int skip=diffpoints/currintervals;
for (int i=0; i< currpoints; i++) {
if (custom[index]) {
spnx[i+(skip*i)]->setValue(g_model.curves[currentCurve].points[i].x);
} else {
spnx[i+(skip*i)]->setValue(-100+(200*i)/currintervals);
}
spny[i+(skip*i)]->setValue(g_model.curves[currentCurve].points[i].y);
if (i>0) {
int diffx=spnx[i+(skip*i)]->value()-spnx[(i-1)+(skip*(i-1))]->value();
int diffy=spny[i+(skip*i)]->value()-spny[(i-1)+(skip*(i-1))]->value();
for (int j=1; j<= skip; j++) {
spny[(i-1)+skip*(i-1)+j]->setValue(spny[(i-1)+(skip*(i-1))]->value()+((diffy*j)/(skip+1)));
spnx[(i-1)+skip*(i-1)+j]->setValue(spnx[(i-1)+(skip*(i-1))]->value()+((diffx*j)/(skip+1)));
}
}
}
} else {
int intervals=numpoint[index]-1;
int diffpoints=currpoints-numpoint[index];
int skip=diffpoints/intervals;
for (int i=0; i< numpoint[index]; i++) {
spnx[i]->setMinimum(-100);
spnx[i]->setMaximum(100);
if (custom[index]) {
spnx[i]->setValue(spnx[i+skip*i]->value());
} else {
spnx[i]->setValue(-100+(200*i)/intervals);
}
spny[i]->setValue(spny[i+skip*i]->value());
}
for (int i=numpoint[index]; i< 17; i++) {
spnx[i]->setValue(0);
spny[i]->setValue(0);
}
}
curvesLock=false;
for (int i=0; i< 17; i++) {
g_model.curves[currentCurve].points[i].x=spnx[i]->value();
g_model.curves[currentCurve].points[i].y=spny[i]->value();
}
g_model.curves[currentCurve].count=numpoint[index];
g_model.curves[currentCurve].custom=custom[index];
setCurrentCurve(currentCurve);
if (redrawCurve)
drawCurve();
updateSettings();
}
void ModelEdit::closeEvent(QCloseEvent *event)
{
QSettings settings("companion9x", "companion9x");
settings.setValue("mepos", pos());
settings.setValue("mesize", size());
event->accept();
}
void ModelEdit::wizard()
{
uint64_t result=0xffffffff;
modelConfigDialog *mcw = new modelConfigDialog(radioData, &result, this);
mcw->exec();
if (result!=0xffffffff) {
applyNumericTemplate(result);
updateSettings();
tabMixes();
} else if (this->isNew) {
memset(&g_model, 0, sizeof(ModelData));
accept();
}
}
Reference in New Issue View Git Blame Copy Permalink