void CDlgOrder::enableOrderDescFields(const CDlgOrder::DialogType dialogType)
{
static const unsigned orderDescFields[] = {
IDC_EDIT_ORDER_ACTION,
IDC_EDIT_ORDER_SIZE,
IDC_EDIT_ORDER_TYPE,
//IDC_EDIT_ORDER_PRICE,
//IDC_EDIT_ORDER_AUX_PRICE,
IDC_EDIT_ORDER_GOOD_AFTER_TIME,
IDC_EDIT_ORDER_GOOD_TILL_DATE,
};
static const size_t orderDescFieldsNum =
sizeof(orderDescFields) / sizeof(orderDescFields[0]);
bool enable = (dialogType == ORDER);
enableFields(orderDescFields, orderDescFieldsNum, enable);
static const unsigned orderDescCommonFields[] = {
IDC_EDIT_ORDER_PRICE,
IDC_EDIT_ORDER_AUX_PRICE,
};
static const size_t orderDescCommonFieldsNum =
sizeof(orderDescCommonFields) / sizeof(orderDescCommonFields[0]);
enable = (dialogType == ORDER || dialogType == CALC_IMPL_VOL || dialogType == CALC_OPTION_PRICE);
enableFields(orderDescCommonFields, orderDescCommonFieldsNum, enable);
}
void CDlgOrder::enableHistDataFields(const CDlgOrder::DialogType dialogType)
{
{
static const unsigned histDataCommonFields[] = {
IDC_EDIT_WHAT_TO_SHOW,
IDC_EDIT_USE_RTH,
};
static const size_t histDataCommonFieldsNum =
sizeof(histDataCommonFields) / sizeof(histDataCommonFields[0]);
bool enable = (dialogType == REQ_HISTORICAL_DATA || dialogType == REQ_REAL_TIME_BARS);
enableFields(histDataCommonFields, histDataCommonFieldsNum, enable);
}
{
static const unsigned histDataFields[] = {
IDC_EDIT_HIST_END_DATE_TIME,
IDC_EDIT_HIST_DURATION,
//IDC_EDIT_WHAT_TO_SHOW,
IDC_EDIT_BAR_SIZE,
//IDC_EDIT_USE_RTH,
IDC_EDIT_DATE_FORMAT,
};
static const size_t histDataFieldsNum =
sizeof(histDataFields) / sizeof(histDataFields[0]);
bool enable = (dialogType == REQ_HISTORICAL_DATA);
enableFields(histDataFields, histDataFieldsNum, enable);
}
}
void PhotoDetails::updateImageInfo() {
if (m_photo.count() == 0) {
disableFields();
} else if (m_photo.count() == 1) {
enableFields();
updateSingleImage();
} else if (m_photo.count() > 1) {
enableFields();
updateMultipleImage();
}
}
void CDlgOrder::enableOptionsFields(const CDlgOrder::DialogType dialogType)
{
static const unsigned optionsFields[] = {
IDC_BTN_OPTIONS,
};
static const size_t optionsFieldsNum =
sizeof(optionsFields) / sizeof(optionsFields[0]);
bool enable = (dialogType == ORDER || dialogType == REQ_HISTORICAL_DATA ||
dialogType == REQ_MKT_DATA || dialogType == REQ_MKT_DEPTH || dialogType == REQ_REAL_TIME_BARS);
enableFields(optionsFields, optionsFieldsNum, enable);
switch(dialogType){
case ORDER:
GetDlgItem(optionsFields[0])->SetWindowTextA("Order Misc Options");
break;
case REQ_HISTORICAL_DATA:
GetDlgItem(optionsFields[0])->SetWindowTextA("Chart Options");
break;
case REQ_MKT_DATA:
GetDlgItem(optionsFields[0])->SetWindowTextA("Mkt Data Options");
break;
case REQ_MKT_DEPTH:
GetDlgItem(optionsFields[0])->SetWindowTextA("Mkt Depth Options");
break;
case REQ_REAL_TIME_BARS:
GetDlgItem(optionsFields[0])->SetWindowTextA("RTB Options");
break;
default:
GetDlgItem(optionsFields[0])->SetWindowTextA("Options");
break;
}
}
void NavigationModeControlTab::readPacket(std::shared_ptr<Packet> packet) {
if (mControlMode)
return;
if (packet->instanceOfMessage()) {
const Message& message = packet->messageCast();
if (message.instanceOf<NavigationModeControl>()) {
enableFields(true);
const NavigationModeControl& msg =
message.typeCast<NavigationModeControl>();
switch (msg.mNavigationMode) {
case 0:
mUi->noOpRadioButton->setChecked(true);
break;
case 1:
mUi->standbyRadioButton->setChecked(true);
break;
case 2:
mUi->navigateRadioButton->setChecked(true);
break;
default:
break;
}
}
}
}
void CDlgOrder::enableContractDescFields(const CDlgOrder::DialogType dialogType)
{
static const unsigned contractDescFields[] = {
IDC_EDIT_CONID,
IDC_EDIT_SYMBOL,
IDC_EDIT_SEC_TYPE,
IDC_EDIT_EXPIRY,
IDC_EDIT_STRIKE,
IDC_EDIT_RIGHT,
IDC_EDIT_MULT,
IDC_EDIT_EXCH,
IDC_EDIT_PRIM_EXCH,
IDC_EDIT_CURRENCY,
IDC_EDIT_LOCAL_SYMBOL,
IDC_EDIT_IS_EXPIRED,
};
static const size_t contractDescFieldsNum =
sizeof(contractDescFields) / sizeof(contractDescFields[0]);
bool enable = (dialogType == ORDER || dialogType == REQ_MKT_DATA ||
dialogType == REQ_MKT_DEPTH || dialogType == REQ_HISTORICAL_DATA ||
dialogType == REQ_REAL_TIME_BARS || dialogType == REQ_CONTRACT_DETAILS ||
dialogType == EXERCISE_OPTIONS || dialogType == CALC_IMPL_VOL ||
dialogType == CALC_OPTION_PRICE);
enableFields(contractDescFields, contractDescFieldsNum, enable);
}
//------------------------------------------------------------------------------
void SdoDialog::startRead()
{
eObdType obdType;
int size = 0;
tOplkError ret;
enableFields(false);
readFields();
obdType = pDataTypeBox->itemData(pDataTypeBox->currentIndex()).value<eObdType>();
switch (obdType)
{
case kObdTypeUInt8:
case kObdTypeInt8:
size = 1;
break;
case kObdTypeUInt16:
case kObdTypeInt16:
size = 2;
break;
case kObdTypeUInt32:
case kObdTypeInt32:
size = 4;
break;
case kObdTypeUInt64:
case kObdTypeInt64:
size = 8;
break;
case kObdTypeVString:
case kObdTypeDomain:
size = 4096*1024;
break;
}
data.resize(size);
ret = oplk_postUserEvent(readButton);
if (ret != kErrorOk)
{
enableFields(true);
}
}
void KOCRBase::stopOCR()
{
enableFields(true);
enableButton( User1, true ); /* start ocr */
enableButton( User2, false ); /* Cancel */
enableButton( Close, true );
stopAnimation();
}
void CDlgOrder::enableMarketDepthFields(const CDlgOrder::DialogType dialogType)
{
static const unsigned marketDepthFields[] = {
IDC_EDIT_NUM_MKT_DEPTH_ROWS,
};
static const size_t marketDepthFieldsNum =
sizeof(marketDepthFields) / sizeof(marketDepthFields[0]);
bool enable = (dialogType == REQ_MKT_DEPTH);
enableFields(marketDepthFields, marketDepthFieldsNum, enable);
}
void KOCRBase::startOCR()
{
/* en- and disable the buttons */
kdDebug(28000) << "Base: Starting OCR" << endl;
enableFields(false);
enableButton( User1, false ); /* Start OCR */
enableButton( User2, true ); /* Stop OCR */
enableButton( Close, true );
startAnimation();
}
void CDlgOrder::enableMarketDataTypeFields(const CDlgOrder::DialogType dialogType)
{
static const unsigned marketDataTypeFields[] = {
IDC_COMBO_MARKET_DATA_TYPE,
};
static const size_t marketDataTypeFieldsNum =
sizeof(marketDataTypeFields) / sizeof(marketDataTypeFields[0]);
bool enable = (dialogType == REQ_MARKET_DATA_TYPE);
enableFields(marketDataTypeFields, marketDataTypeFieldsNum, enable);
}
void TimeStatusTab::readPacket(std::shared_ptr<Packet> packet) {
if (packet->instanceOfGroup()) {
const Group& group = packet->groupCast();
if (group.instanceOf<PPSTimeRecoveryStatus>()) {
enableFields(true);
const PPSTimeRecoveryStatus& msg =
group.typeCast<PPSTimeRecoveryStatus>();
mUi->gpsTimeSpinBox->setValue(msg.mTimeDistance.mTime1);
mUi->posTimeSpinBox->setValue(msg.mTimeDistance.mTime2);
mUi->distanceSpinBox->setValue(msg.mTimeDistance.mDistanceTag);
}
}
}
void CDlgOrder::enableMarketDataFields(const CDlgOrder::DialogType dialogType)
{
static const unsigned marketDataFields[] = {
IDC_EDIT_GENERIC_TICKS,
IDC_CHECK_SNAPSHOT_MKT_DATA,
};
static const size_t marketDataFieldsNum =
sizeof(marketDataFields) / sizeof(marketDataFields[0]);
bool enable = (dialogType == REQ_MKT_DATA);
enableFields(marketDataFields, marketDataFieldsNum, enable);
}
void CDlgOrder::enableComboFields(const CDlgOrder::DialogType dialogType)
{
static const unsigned comboFields[] = {
IDC_BTN_ADD_COMBO_LEGS,
IDC_BTN_UNDER_COMP,
};
static const size_t comboFieldsNum =
sizeof(comboFields) / sizeof(comboFields[0]);
bool enable = (dialogType == ORDER || dialogType == REQ_MKT_DATA);
enableFields(comboFields, comboFieldsNum, enable);
}
void CDlgOrder::enableSecIdFields(const CDlgOrder::DialogType dialogType)
{
{
static const unsigned secIdFields[] = {
IDC_EDIT_SEC_ID_TYPE,
IDC_EDIT_SEC_ID
};
static const size_t secIdFieldsNum =
sizeof(secIdFields) / sizeof(secIdFields[0]);
bool enable = (dialogType == REQ_CONTRACT_DETAILS || dialogType == ORDER);
enableFields(secIdFields, secIdFieldsNum, enable);
}
}
void CDlgOrder::enableExerciseOptionsFields(const CDlgOrder::DialogType dialogType)
{
static const unsigned exerciseOptionsFields[] = {
IDC_EDIT_EXERCISE_ACTION,
IDC_EDIT_EXERCISE_QUANTITY,
IDC_EDIT_EXERCISE_OVERRIDE,
};
static const size_t exerciseOptionsFieldsNum =
sizeof(exerciseOptionsFields) / sizeof(exerciseOptionsFields[0]);
bool enable = (dialogType == EXERCISE_OPTIONS);
enableFields(exerciseOptionsFields, exerciseOptionsFieldsNum, enable);
}
void UserAccuracySpecTab::readPacket(std::shared_ptr<Packet> packet) {
if (mControlMode)
return;
if (packet->instanceOfMessage()) {
const Message& message = packet->messageCast();
if (message.instanceOf<UserAccuracySpec>()) {
enableFields(true);
const UserAccuracySpec& msg = message.typeCast<UserAccuracySpec>();
mUi->attAccSpinBox->setValue(msg.mAttitudeAccuracy);
mUi->headingAccSpinBox->setValue(msg.mHeadingAccuracy);
mUi->posAccSpinBox->setValue(msg.mPositionAccuracy);
mUi->velAccSpinBox->setValue(msg.mVelocityAccuracy);
}
}
}
void CDlgOrder::enableComboFields(const CDlgOrder::DialogType dialogType)
{
static const unsigned comboFields[] = {
IDC_BTN_ADD_COMBO_LEGS,
};
static const size_t comboFieldsNum =
sizeof(comboFields) / sizeof(comboFields[0]);
bool enable = (dialogType == ORDER ||
dialogType == REQ_MKT_DATA ||
dialogType == REQ_HISTORICAL_DATA);
enableFields(comboFields, comboFieldsNum, enable);
static const unsigned deltaNeutralFields[] = {
IDC_BTN_UNDER_COMP,
};
static const size_t deltaNeutralFieldsNum =
sizeof(deltaNeutralFields) / sizeof(deltaNeutralFields[0]);
enable = (dialogType == ORDER ||
dialogType == REQ_MKT_DATA);
enableFields(deltaNeutralFields, deltaNeutralFieldsNum, enable);
static const unsigned algoFields[] = {
IDC_BTN_ALGO_PARAMS,
IDC_BTN_SMART_COMBO_ROUTING_PARAMS,
};
static const size_t algoFieldsNum =
sizeof(algoFields) / sizeof(algoFields[0]);
enable = (dialogType == ORDER);
enableFields(algoFields, algoFieldsNum, enable);
}
void NavigationTab::readPacket(std::shared_ptr<Packet> packet) {
if (packet->instanceOfGroup()) {
const Group& group = packet->groupCast();
if (group.instanceOf<VehicleNavigationSolution>()) {
enableFields(true);
const VehicleNavigationSolution& msg =
group.typeCast<VehicleNavigationSolution>();
mUi->latSpinBox->setValue(msg.mLatitude);
mUi->longSpinBox->setValue(msg.mLongitude);
mUi->altSpinBox->setValue(msg.mAltitude);
mUi->velNorthSpinBox->setValue(msg.mNorthVelocity);
mUi->velEastSpinBox->setValue(msg.mEastVelocity);
mUi->velDownSpinBox->setValue(msg.mDownVelocity);
mUi->rollSpinBox->setValue(msg.mRoll);
mUi->pitchSpinBox->setValue(msg.mPitch);
mUi->headingSpinBox->setValue(msg.mHeading);
mUi->wanderSpinBox->setValue(msg.mWanderAngle);
mUi->trackSpinBox->setValue(msg.mTrackAngle);
mUi->speedSpinBox->setValue(msg.mSpeed);
mUi->rateLongSpinBox->setValue(msg.mAngularRateLong);
mUi->rateTransSpinBox->setValue(msg.mAngularRateTrans);
mUi->rateDownSpinBox->setValue(msg.mAngularRateDown);
mUi->accLongSpinBox->setValue(msg.mAccLong);
mUi->accTransSpinBox->setValue(msg.mAccTrans);
mUi->accDownSpinBox->setValue(msg.mAccDown);
mUi->alignmentText->setText(mStatusMsg[msg.mAlignementStatus].c_str());
emit updatePosition(msg.mLatitude, msg.mLongitude, msg.mAltitude);
}
else if (group.instanceOf<VehicleNavigationPerformance>()) {
const VehicleNavigationPerformance& msg =
group.typeCast<VehicleNavigationPerformance>();
mUi->posNorthRMSSpinBox->setValue(msg.mNorthPositionRMSError);
mUi->posEastRMSSpinBox->setValue(msg.mEastPositionRMSError);
mUi->posDownRMSSpinBox->setValue(msg.mDownPositionRMSError);
mUi->velNorthRMSSpinBox->setValue(msg.mNorthVelocityRMSError);
mUi->velEastRMSSpinBox->setValue(msg.mEastVelocityRMSError);
mUi->velDownRMSSpinBox->setValue(msg.mDownVelocityRMSError);
mUi->rollRMSSpinBox->setValue(msg.mRollRMSError);
mUi->pitchRMSSpinBox->setValue(msg.mPitchRMSError);
mUi->headingRMSSpinBox->setValue(msg.mHeadingRMSError);
mUi->semiMajorSpinBox->setValue(msg.mErrorEllipsoidSemiMajor);
mUi->semiMinorSpinBox->setValue(msg.mErrorEllipsoidSemiMinor);
mUi->orientationSpinBox->setValue(msg.mErrorEllipsoidOrientation);
emit updateUncertainty(msg.mNorthPositionRMSError,
msg.mEastPositionRMSError, msg.mDownPositionRMSError);
}
}
}
void AidingSensorInstallParamsTab::readPacket(std::shared_ptr<Packet>
packet) {
if (mControlMode)
return;
if (packet->instanceOfMessage()) {
const Message& message = packet->messageCast();
if (message.instanceOf<AidingSensorInstallParams>()) {
enableFields(true);
const AidingSensorInstallParams& msg =
message.typeCast<AidingSensorInstallParams>();
mUi->dmiScaleSpinBox->setValue(msg.mDMIScaleFactor);
mUi->dmiXSpinBox->setValue(msg.mRefDMIX);
mUi->dmiYSpinBox->setValue(msg.mRefDMIY);
mUi->dmiZSpinBox->setValue(msg.mRefDMIZ);
}
}
}
OcrEngine::EngineError KadmosDialog::setupGui()
{
OcrEngine::EngineError err = OcrBaseDialog::setupGui();
// setupPreprocessing( addVBoxPage( i18n("Preprocessing")));
// setupSegmentation( addVBoxPage( i18n("Segmentation")));
// setupClassification( addVBoxPage( i18n("Classification")));
/* continue page setup on the first page */
KVBox *page = new KVBox(this);
// FIXME: dynamic classifier reading.
new QLabel(i18n("Please classify the font type and language of the text on the image:"), page);
KHBox *locBox = new KHBox( page );
m_bbFont = new Q3ButtonGroup(1, Qt::Horizontal, i18n("Font Type Selection"), locBox);
m_rbMachine = new QRadioButton( i18n("Machine print"), m_bbFont );
m_rbHand = new QRadioButton( i18n("Hand writing"), m_bbFont );
m_rbNorm = new QRadioButton( i18n("Norm font"), m_bbFont );
m_gbLang = new Q3GroupBox(1, Qt::Horizontal, i18n("Country"), locBox);
m_cbLang = new QComboBox( m_gbLang );
m_cbLang->setItemText(m_cbLang->currentIndex(), KLocale::defaultCountry());
connect( m_bbFont, SIGNAL(clicked(int)), this, SLOT(slFontChanged(int) ));
m_rbMachine->setChecked(true);
/* --- */
KHBox *innerBox = new KHBox( page );
innerBox->setSpacing( KDialog::spacingHint());
Q3ButtonGroup *cbGroup = new Q3ButtonGroup( 1, Qt::Horizontal, i18n("OCR Modifier"), innerBox );
Q_CHECK_PTR(cbGroup);
m_cbNoise = new QCheckBox( i18n( "Enable automatic noise reduction" ), cbGroup );
m_cbAutoscale = new QCheckBox( i18n( "Enable automatic scaling"), cbGroup );
addExtraSetupWidget(page);
if( err != OcrEngine::ENG_OK )
{
enableFields(false);
enableButton(User1, false );
}
if( m_ttfClassifier.count() == 0 )
{
m_rbMachine->setEnabled(false);
}
if( m_handClassifier.count() == 0 )
{
m_rbHand->setEnabled(false);
}
if( !m_haveNorm )
m_rbNorm->setEnabled(false);
if( (m_ttfClassifier.count() + m_handClassifier.count()) == 0 && ! m_haveNorm )
{
KMessageBox::error(0, i18n("The classifier files for KADMOS could not be found.\n"
"OCR with KADMOS will not be possible.\n\n"
"Change the OCR engine in the preferences dialog."),
i18n("Installation Error") );
err = OcrEngine::ENG_BAD_SETUP;
}
else
slotFontChanged( 0 ); // Load machine print font language list
ocrShowInfo(QString::null);
return err;
}
void CalibratedInstallationParamsTab::readPacket(std::shared_ptr<Packet>
packet) {
if (packet->instanceOfGroup()) {
const Group& group = packet->groupCast();
if (group.instanceOf<CalibratedInstallationParams>()) {
enableFields(true);
const CalibratedInstallationParams& msg =
group.typeCast<CalibratedInstallationParams>();
mUi->primGPSXSpinBox->setValue(msg.mReferenceToPrimaryGPSXLeverArm);
mUi->primGPSYSpinBox->setValue(msg.mReferenceToPrimaryGPSYLeverArm);
mUi->primGPSZSpinBox->setValue(msg.mReferenceToPrimaryGPSZLeverArm);
mUi->primGPSFOMSpinBox->setValue(
msg.mReferenceToPrimaryGPSLeverArmCalibrationFOM);
mUi->aux1GPSXSpinBox->setValue(msg.mReferenceToAuxiliary1GPSXLeverArm);
mUi->aux1GPSYSpinBox->setValue(msg.mReferenceToAuxiliary1GPSYLeverArm);
mUi->aux1GPSZSpinBox->setValue(msg.mReferenceToAuxiliary1GPSZLeverArm);
mUi->aux1GPSFOMSpinBox->setValue(
msg.mReferenceToAuxiliary1GPSLeverArmCalibrationFOM);
mUi->aux2GPSXSpinBox->setValue(msg.mReferenceToAuxiliary2GPSXLeverArm);
mUi->aux2GPSYSpinBox->setValue(msg.mReferenceToAuxiliary2GPSYLeverArm);
mUi->aux2GPSZSpinBox->setValue(msg.mReferenceToAuxiliary2GPSZLeverArm);
mUi->aux2GPSFOMSpinBox->setValue(
msg.mReferenceToAuxiliary2GPSLeverArmCalibrationFOM);
mUi->dmiXSpinBox->setValue(msg.mReferenceToDMIXLeverArm);
mUi->dmiYSpinBox->setValue(msg.mReferenceToDMIYLeverArm);
mUi->dmiZSpinBox->setValue(msg.mReferenceToDMIZLeverArm);
mUi->dmiFOMSpinBox->setValue(msg.mReferenceToDMILeverArmCalibrationFOM);
mUi->dmiScaleSpinBox->setValue(msg.mDMIScaleFactor);
mUi->dmiScaleFOMSpinBox->setValue(msg.mDMIScaleFactorCalibrationFOM);
std::bitset<16> status(msg.mCalibrationStatus);
for (size_t i = 0; i < 16; i++) {
switch (i) {
case 0:
if (status.test(i))
mUi->primGPSProgressLed->setColor(Qt::green);
else
mUi->primGPSProgressLed->setColor(Qt::red);
break;
case 3:
if (status.test(i))
mUi->dmiLeverProgressLed->setColor(Qt::green);
else
mUi->dmiLeverProgressLed->setColor(Qt::red);
break;
case 4:
if (status.test(i))
mUi->dmiScaleProgressLed->setColor(Qt::green);
else
mUi->dmiScaleProgressLed->setColor(Qt::red);
break;
case 6:
if (status.test(i))
mUi->fixLeverProgressLed->setColor(Qt::green);
else
mUi->fixLeverProgressLed->setColor(Qt::red);
break;
case 8:
if (status.test(i))
mUi->primGPSCompleteLed->setColor(Qt::green);
else
mUi->primGPSCompleteLed->setColor(Qt::red);
break;
case 11:
if (status.test(i))
mUi->dmiLeverCompleteLed->setColor(Qt::green);
else
mUi->dmiLeverCompleteLed->setColor(Qt::red);
break;
case 12:
if (status.test(i))
mUi->dmiScaleCompleteLed->setColor(Qt::green);
else
mUi->dmiScaleCompleteLed->setColor(Qt::red);
break;
case 14:
if (status.test(i))
mUi->fixLeverCompleteLed->setColor(Qt::green);
else
mUi->fixLeverCompleteLed->setColor(Qt::red);
break;
default:
break;
}
}
}
}
}
void PrimaryGPSStatusTab::readPacket(std::shared_ptr<Packet> packet) {
if (packet->instanceOfGroup()) {
const Group& group = packet->groupCast();
if (group.instanceOf<PrimaryGPSStatus>()) {
enableFields(true);
const PrimaryGPSStatus& msg = group.typeCast<PrimaryGPSStatus>();
mUi->navPrimGPSText->setText(
mStatusMsg[msg.mNavigationSolutionStatus].c_str());
mUi->satPrimGPSSpinBox->setValue(msg.mNumberOfSVTracked);
mUi->primGPSTypeText->setText(mGPSTypeMsg[msg.mGPSReceiverType].c_str());
mUi->geoidalPrimGPSSpinBox->setValue(msg.mGeoidalSeparation);
mUi->hdopSpinBox->setValue(msg.mHDOP);
mUi->vdopSpinBox->setValue(msg.mVDOP);
mUi->dgpsIDSpinBox->setValue(msg.mDGPSReferenceID);
mUi->corrLatencySpinBox->setValue(msg.mDGPSCorrectionLatency);
mUi->navLatencySpinBox->setValue(msg.mGPSNavigationMessageLatency);
mUi->weekSpinBox->setValue(msg.mGPSUTCWeekNumber);
mUi->offsetSpinBox->setValue(msg.mGPSUTCTimeOffset);
while (mUi->channelsTable->rowCount())
mUi->channelsTable->removeRow(mUi->channelsTable->rowCount() - 1);
for (size_t i = 0; i < msg.mChannelNumber; ++i) {
mUi->channelsTable->insertRow(mUi->channelsTable->rowCount());
QSpinBox* PRN = new QSpinBox;
PRN->setReadOnly(true);
PRN->setValue(msg.mChannelStatusData[i].mSVPRN);
PRN->setButtonSymbols(QAbstractSpinBox::NoButtons);
mUi->channelsTable->setCellWidget(mUi->channelsTable->rowCount() - 1, 0,
PRN);
QLineEdit* status = new QLineEdit;
status->setReadOnly(true);
status->setText(mChannelStatusMsg[
msg.mChannelStatusData[i].mChannelTrackingStatus].c_str());
mUi->channelsTable->setCellWidget(mUi->channelsTable->rowCount() - 1, 1,
status);
QDoubleSpinBox* azimuth = new QDoubleSpinBox;
azimuth->setReadOnly(true);
azimuth->setValue(msg.mChannelStatusData[i].mSVAzimuth);
azimuth->setButtonSymbols(QAbstractSpinBox::NoButtons);
mUi->channelsTable->setCellWidget(mUi->channelsTable->rowCount() - 1, 2,
azimuth);
QDoubleSpinBox* elevation = new QDoubleSpinBox;
elevation->setReadOnly(true);
elevation->setValue(msg.mChannelStatusData[i].mSVElevation);
elevation->setButtonSymbols(QAbstractSpinBox::NoButtons);
mUi->channelsTable->setCellWidget(mUi->channelsTable->rowCount() - 1, 3,
elevation);
QDoubleSpinBox* l1snr = new QDoubleSpinBox;
l1snr->setReadOnly(true);
l1snr->setValue(msg.mChannelStatusData[i].mSVL1SNR);
l1snr->setButtonSymbols(QAbstractSpinBox::NoButtons);
mUi->channelsTable->setCellWidget(mUi->channelsTable->rowCount() - 1, 4,
l1snr);
QDoubleSpinBox* l2snr = new QDoubleSpinBox;
l2snr->setReadOnly(true);
l2snr->setValue(msg.mChannelStatusData[i].mSVL2SNR);
l2snr->setButtonSymbols(QAbstractSpinBox::NoButtons);
mUi->channelsTable->setCellWidget(mUi->channelsTable->rowCount() - 1, 5,
l2snr);
}
}
if (group.instanceOf<PPSTimeRecoveryStatus>()) {
const PPSTimeRecoveryStatus& msg =
group.typeCast<PPSTimeRecoveryStatus>();
mUi->ppsSpinBox->setValue(msg.mPPSCount);
mUi->timeStatusText->setText(
mTimeSyncMsg[msg.mTimeSynchroStatus].c_str());
}
}
}
//------------------------------------------------------------------------------
void SdoDialog::updateData(const QString& abortCode_p)
{
QString dataString;
eObdType obdType;
if (abortCode_p != "")
{
pAbortCodeLabel->setText(abortCode_p);
}
obdType = pDataTypeBox->itemData(pDataTypeBox->currentIndex()).value<eObdType>();
switch (obdType)
{
case kObdTypeUInt8:
if (data.size() >= 1)
{
unsigned int val = *(unsigned char*)data.data();
dataString = QString("0x%1 = %2")
.arg(val, 2, 16, QLatin1Char('0'))
.arg(val);
}
else
{
dataString = "Too less data for UNSIGNED8";
}
break;
case kObdTypeInt8:
if (data.size() >= 1)
{
int val = *(INT8*)data.data();
dataString = QString("%1")
.arg(val);
}
else
{
dataString = "Too less data for INTEGER8";
}
break;
case kObdTypeUInt16:
if (data.size() >= 2)
{
unsigned int val = qFromLittleEndian<quint16>((const uchar*)data.data());
dataString = QString("0x%1 = %2")
.arg(val, 4, 16, QLatin1Char('0'))
.arg(val);
}
else
{
dataString = "Too less data for UNSIGNED16";
}
break;
case kObdTypeInt16:
if (data.size() >= 2)
{
int val = qFromLittleEndian<qint16>((const uchar*)data.data());
dataString = QString("%1")
.arg(val);
}
else
{
dataString = "Too less data for INTEGER16";
}
break;
case kObdTypeUInt32:
if (data.size() >= 4)
{
unsigned int val = qFromLittleEndian<quint32>((const uchar*)data.data());
dataString = QString("0x%1 = %2")
.arg(val, 8, 16, QLatin1Char('0'))
.arg(val);
}
else
{
dataString = "Too less data for UNSIGNED32";
}
break;
case kObdTypeInt32:
if (data.size() >= 4)
{
int val = qFromLittleEndian<qint32>((const uchar*)data.data());
dataString = QString("%1")
.arg(val);
}
else
{
dataString = "Too less data for INTEGER32";
}
break;
case kObdTypeUInt64:
if (data.size() >= 8)
{
qulonglong val = qFromLittleEndian<quint64>((const uchar*)data.data());
dataString = QString("0x%1 = %2")
.arg(val, 16, 16, QLatin1Char('0'))
.arg(val);
}
else
{
dataString = "Too less data for UNSIGNED64";
}
break;
case kObdTypeInt64:
if (data.size() >= 8)
{
qlonglong val = qFromLittleEndian<qint64>((const uchar*)data.data());
dataString = QString("%1")
.arg(val);
}
else
{
dataString = "Too less data for INTEGER64";
}
break;
case kObdTypeVString:
dataString = QString(data);
break;
case kObdTypeDomain:
dataString = QString(data.toHex());
break;
}
pDataEdit->setText(dataString);
enableFields(true);
}
//------------------------------------------------------------------------------
void SdoDialog::startWrite()
{
eObdType obdType;
int size = 0;
tOplkError ret;
enableFields(false);
readFields();
obdType = pDataTypeBox->itemData(pDataTypeBox->currentIndex()).value<eObdType>();
switch (obdType)
{
case kObdTypeVString:
data = pDataEdit->text().toAscii();
break;
case kObdTypeDomain:
data = QByteArray::fromHex(pDataEdit->text().toAscii());
break;
default:
QStringList list = pDataEdit->text().split(QRegExp("[^0-9a-fA-Fx]+"), QString::SkipEmptyParts);
if (list.count() < 1)
{
QMessageBox::critical(this, "Data invalid",
"The specified data field does not consist of one number. Please correct and try again.");
enableFields(true);
return;
}
bool fConvOk = false;
quint64 uval;
qint64 val;
switch (obdType)
{
case kObdTypeUInt8:
case kObdTypeUInt16:
case kObdTypeUInt32:
case kObdTypeUInt64:
uval = list[0].toULongLong(&fConvOk, 0);
if (!fConvOk)
{
QMessageBox::critical(this, "Data invalid",
"The specified data format is not an unsigned integer. Please correct and try again.");
enableFields(true);
return;
}
data.resize(8);
qToLittleEndian<quint64>(uval, (uchar*)data.data());
break;
case kObdTypeInt8:
case kObdTypeInt16:
case kObdTypeInt32:
case kObdTypeInt64:
val = list[0].toLongLong(&fConvOk, 0);
if (!fConvOk)
{
QMessageBox::critical(this, "Data invalid",
"The specified data format is not a signed integer. Please correct and try again.");
enableFields(true);
return;
}
data.resize(8);
qToLittleEndian<qint64>(val, (uchar*)data.data());
break;
}
switch (obdType)
{
case kObdTypeUInt8:
case kObdTypeInt8:
size = 1;
break;
case kObdTypeUInt16:
case kObdTypeInt16:
size = 2;
break;
case kObdTypeUInt32:
case kObdTypeInt32:
size = 4;
break;
case kObdTypeUInt64:
case kObdTypeInt64:
size = 8;
break;
}
data.resize(size);
}
ret = oplk_postUserEvent(writeButton);
if (ret != kErrorOk)
{
enableFields(true);
}
}
