File indexing completed on 2024-04-28 03:43:18

 /*
     SPDX-FileCopyrightText: 2012 Jasem Mutlaq <mutlaqja@ikarustech.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "sequencejob.h"
 
 #include <KNotifications/KNotification>
 #include <ekos_capture_debug.h>
 #include "capturedeviceadaptor.h"
 #include "skyobjects/skypoint.h"
 #include "ksnotification.h"
 
 #define MF_TIMER_TIMEOUT    90000
 #define MF_RA_DIFF_LIMIT    4
 
 namespace Ekos
 {
 QString const &SequenceJob::ISOMarker("_ISO8601");
 
 const QStringList SequenceJob::StatusStrings()
 {
     static const QStringList names = {i18n("Idle"), i18n("In Progress"), i18n("Error"), i18n("Aborted"),
                                       i18n("Complete")
                                      };
     return names;
 }
 
 
 /**
  * @brief SequenceJob::SequenceJob Construct job from XML source
  * @param root pointer to valid job stored in XML format.
  */
 SequenceJob::SequenceJob(XMLEle * root, QString targetName)
 {
     // set own unconnected state machine
     QSharedPointer<CaptureModuleState> sharedState;
     sharedState.reset(new CaptureModuleState);
     state.reset(new SequenceJobState(sharedState));
     // set simple device adaptor
     devices.reset(new CaptureDeviceAdaptor());
 
     init(SequenceJob::JOBTYPE_BATCH, root, sharedState, targetName);
 }
 
 SequenceJob::SequenceJob(const QSharedPointer<CaptureDeviceAdaptor> cp,
                          const QSharedPointer<CaptureModuleState> sharedState,
                          SequenceJobType jobType, XMLEle *root, QString targetName)
 {
     devices = cp;
     init(jobType, root, sharedState, targetName);
 }
 
 void Ekos::SequenceJob::init(SequenceJobType jobType, XMLEle *root,
                              QSharedPointer<CaptureModuleState> sharedState,
                              const QString &targetName)
 {
     // initialize the state machine
     state.reset(new SequenceJobState(sharedState));
 
     loadFrom(root, targetName, jobType, sharedState);
 
     // signal forwarding between this and the state machine
     connect(state.data(), &SequenceJobState::prepareState, this, &SequenceJob::prepareState);
     connect(state.data(), &SequenceJobState::prepareComplete, this, &SequenceJob::processPrepareComplete);
     connect(state.data(), &SequenceJobState::abortCapture, this, &SequenceJob::processAbortCapture);
     connect(state.data(), &SequenceJobState::newLog, this, &SequenceJob::newLog);
     // start capturing as soon as the capture initialization is complete
     connect(state.data(), &SequenceJobState::initCaptureComplete, this, &SequenceJob::capture);
 
     // finish if XML document empty
     if (root == nullptr)
         return;
 
     // create signature with current target
     auto placeholderPath = Ekos::PlaceholderPath();
     placeholderPath.processJobInfo(this);
 }
 
 void SequenceJob::resetStatus(JOBStatus status)
 {
     setStatus(status);
     setCalibrationStage(SequenceJobState::CAL_NONE);
     switch (status)
     {
         case JOB_IDLE:
             setCompleted(0);
             // 2022.03.10: Keeps failing on Windows despite installing latest libindi
 #ifndef Q_OS_WIN
             INDI_FALLTHROUGH;
 #endif
         case JOB_ERROR:
         case JOB_ABORTED:
         case JOB_DONE:
             m_ExposeLeft     = 0;
             m_CaptureRetires = 0;
             m_JobProgressIgnored = false;
             break;
         case JOB_BUSY:
             // do nothing
             break;
     }
 }
 
 void SequenceJob::abort()
 {
     setStatus(JOB_ABORTED);
     if (devices.data()->getActiveChip())
     {
         if (devices.data()->getActiveChip()->canAbort())
             devices.data()->getActiveChip()->abortExposure();
         devices.data()->getActiveChip()->setBatchMode(false);
     }
 }
 
 void SequenceJob::done()
 {
     setStatus(JOB_DONE);
 }
 
 int SequenceJob::getJobRemainingTime(double estimatedDownloadTime)
 {
     double remaining = (getCoreProperty(SJ_Exposure).toDouble() +
                         estimatedDownloadTime +
                         getCoreProperty(SJ_Delay).toDouble() / 1000) *
                        (getCoreProperty(SJ_Count).toDouble() - getCompleted());
 
     if (getStatus() == JOB_BUSY)
     {
         if (getExposeLeft() > 0.0)
             remaining -= getCoreProperty(SJ_Exposure).toDouble() - getExposeLeft();
         else
             remaining += getExposeLeft() + estimatedDownloadTime;
     }
 
     return static_cast<int>(std::round(remaining));
 }
 
 void SequenceJob::setStatus(JOBStatus const in_status)
 {
     state->reset(in_status);
 }
 
 void SequenceJob::setISO(int index)
 {
     if (devices->getActiveChip())
     {
         setCoreProperty(SequenceJob::SJ_ISOIndex, index);
         const auto isolist = devices->getActiveChip()->getISOList();
         if (isolist.count() > index && index >= 0)
             setCoreProperty(SequenceJob::SJ_ISO, isolist[index]);
     }
 }
 
 QStringList SequenceJob::frameTypes() const
 {
     if (!devices->getActiveCamera())
         return QStringList({"Light", "Bias", "Dark", "Flat"});
 
     ISD::CameraChip *tChip = devices->getActiveCamera()->getChip(ISD::CameraChip::PRIMARY_CCD);
 
     return tChip->getFrameTypes();
 }
 
 QStringList SequenceJob::filterLabels() const
 {
     if (devices->getFilterManager().isNull())
         return QStringList();
 
     return devices->getFilterManager()->getFilterLabels();
 
 }
 
 void SequenceJob::connectDeviceAdaptor()
 {
     devices->setCurrentSequenceJobState(state);
     // connect state machine with device adaptor
     connect(state.data(), &SequenceJobState::readCurrentState, devices.data(),
             &CaptureDeviceAdaptor::readCurrentState);
     connect(state.data(), &SequenceJobState::flatSyncFocus, devices.data(),
             &CaptureDeviceAdaptor::flatSyncFocus);
     // connect device adaptor with state machine
     connect(devices.data(), &CaptureDeviceAdaptor::flatSyncFocusChanged, state.data(),
             &SequenceJobState::flatSyncFocusChanged);
 }
 
 void SequenceJob::disconnectDeviceAdaptor()
 {
     devices->disconnectDevices(state.data());
     disconnect(state.data(), &SequenceJobState::readCurrentState, devices.data(),
                &CaptureDeviceAdaptor::readCurrentState);
     disconnect(state.data(), &SequenceJobState::flatSyncFocus, devices.data(),
                &CaptureDeviceAdaptor::flatSyncFocus);
     disconnect(devices.data(), &CaptureDeviceAdaptor::flatSyncFocusChanged, state.data(),
                &SequenceJobState::flatSyncFocusChanged);
 }
 
 void SequenceJob::startCapturing(bool autofocusReady, FITSMode mode)
 {
     state->initCapture(getFrameType(), jobType() == SequenceJob::JOBTYPE_PREVIEW, autofocusReady, mode);
 }
 
 void SequenceJob::capture(FITSMode mode)
 {
     if (!devices.data()->getActiveCamera() || !devices.data()->getActiveChip())
         return;
 
     // initialize the log entry
     QString logentry = QString("Capture exposure = %1 sec, type = %2").arg(getCoreProperty(SJ_Exposure).toDouble()).arg(
                            CCDFrameTypeNames[getFrameType()]);
     logentry.append(QString(", filter = %1, upload mode = %2").arg(getCoreProperty(SJ_Filter).toString()).arg(getUploadMode()));
 
     devices.data()->getActiveChip()->setBatchMode(jobType() != SequenceJob::JOBTYPE_PREVIEW);
     devices.data()->getActiveCamera()->setSeqPrefix(getCoreProperty(SJ_FullPrefix).toString());
     logentry.append(QString(", batch mode = %1, seq prefix = %2").arg(jobType() != SequenceJob::JOBTYPE_PREVIEW ? "true" :
                     "false").arg(getCoreProperty(SJ_FullPrefix).toString()));
 
     if (jobType() == SequenceJob::JOBTYPE_PREVIEW)
     {
         if (devices.data()->getActiveCamera()->getUploadMode() != ISD::Camera::UPLOAD_CLIENT)
             devices.data()->getActiveCamera()->setUploadMode(ISD::Camera::UPLOAD_CLIENT);
     }
     else
         devices.data()->getActiveCamera()->setUploadMode(m_UploadMode);
 
     QMapIterator<QString, QMap<QString, QVariant>> i(m_CustomProperties);
     while (i.hasNext())
     {
         i.next();
         auto customProp = devices.data()->getActiveCamera()->getProperty(i.key());
         if (customProp)
         {
             QMap<QString, QVariant> elements = i.value();
             QMapIterator<QString, QVariant> j(elements);
 
             switch (customProp.getType())
             {
                 case INDI_SWITCH:
                 {
                     auto sp = customProp.getSwitch();
                     while (j.hasNext())
                     {
                         j.next();
                         auto oneSwitch = sp->findWidgetByName(j.key().toLatin1().data());
                         if (oneSwitch)
                             oneSwitch->setState(static_cast<ISState>(j.value().toInt()));
                     }
                     devices.data()->getActiveCamera()->sendNewProperty(sp);
                 }
                 break;
                 case INDI_TEXT:
                 {
                     auto tp = customProp.getText();
                     while (j.hasNext())
                     {
                         j.next();
                         auto oneText = tp->findWidgetByName(j.key().toLatin1().data());
                         if (oneText)
                             oneText->setText(j.value().toString().toLatin1().constData());
                     }
                     devices.data()->getActiveCamera()->sendNewProperty(tp);
                 }
                 break;
                 case INDI_NUMBER:
                 {
                     auto np = customProp.getNumber();
                     while (j.hasNext())
                     {
                         j.next();
                         auto oneNumber = np->findWidgetByName(j.key().toLatin1().data());
                         if (oneNumber)
                             oneNumber->setValue(j.value().toDouble());
                     }
                     devices.data()->getActiveCamera()->sendNewProperty(np);
                 }
                 break;
                 default:
                     continue;
             }
         }
     }
 
     const auto remoteFormatDirectory = getCoreProperty(SJ_RemoteFormatDirectory).toString();
     const auto remoteFormatFilename = getCoreProperty(SJ_RemoteFormatFilename).toString();
     if (devices.data()->getActiveChip()->isBatchMode() &&
             remoteFormatDirectory.isEmpty() == false &&
             remoteFormatFilename.isEmpty() == false)
     {
         devices.data()->getActiveCamera()->updateUploadSettings(remoteFormatDirectory, remoteFormatFilename);
         if (getUploadMode() != ISD::Camera::UPLOAD_CLIENT)
             logentry.append(QString(", remote dir = %1, remote format = %2").arg(remoteFormatDirectory).arg(remoteFormatFilename));
     }
 
     const int ISOIndex = getCoreProperty(SJ_ISOIndex).toInt();
     if (ISOIndex != -1)
     {
         logentry.append(QString(", ISO index = %1").arg(ISOIndex));
         if (ISOIndex != devices.data()->getActiveChip()->getISOIndex())
             devices.data()->getActiveChip()->setISOIndex(ISOIndex);
     }
 
     const auto gain = getCoreProperty(SJ_Gain).toDouble();
     if (gain >= 0)
     {
         logentry.append(QString(", gain = %1").arg(gain));
         devices.data()->getActiveCamera()->setGain(gain);
     }
 
     const auto offset = getCoreProperty(SJ_Offset).toDouble();
     if (offset >= 0)
     {
         logentry.append(QString(", offset = %1").arg(offset));
         devices.data()->getActiveCamera()->setOffset(offset);
     }
 
     devices.data()->getActiveCamera()->setCaptureFormat(getCoreProperty(SJ_Format).toString());
     devices.data()->getActiveCamera()->setEncodingFormat(getCoreProperty(SJ_Encoding).toString());
     devices.data()->getActiveChip()->setFrameType(getFrameType());
     logentry.append(QString(", format = %1, encoding = %2").arg(getCoreProperty(SJ_Format).toString()).arg(getCoreProperty(
                         SJ_Encoding).toString()));
 
     // Only attempt to set ROI and Binning if CCD transfer format is FITS or XISF
     int currentBinX = 1, currentBinY = 1;
     devices.data()->getActiveChip()->getBinning(&currentBinX, &currentBinY);
 
     const auto binning = getCoreProperty(SJ_Binning).toPoint();
     // N.B. Always set binning _before_ setting frame because if the subframed image
     // is problematic in 1x1 but works fine for 2x2, then it would fail it was set first
     // So setting binning first always ensures this will work.
     if (devices.data()->getActiveChip()->canBin())
     {
         if (devices.data()->getActiveChip()->setBinning(binning.x(), binning.y()) == false)
         {
             qCWarning(KSTARS_EKOS_CAPTURE()) << "Cannot set binning to " << "x =" << binning.x() << ", y =" << binning.y();
             setStatus(JOB_ERROR);
             emit captureStarted(CaptureModuleState::CAPTURE_BIN_ERROR);
         }
         else
             logentry.append(QString(", binning = %1x%2").arg(binning.x()).arg(binning.y()));
     }
     else
         logentry.append(QString(", Cannot bin"));
 
 
     const auto roi = getCoreProperty(SJ_ROI).toRect();
 
     if (devices.data()->getActiveChip()->canSubframe())
     {
         if ((roi.width() > 0 && roi.height() > 0) && devices.data()->getActiveChip()->setFrame(roi.x(),
                 roi.y(),
                 roi.width(),
                 roi.height(),
                 currentBinX != binning.x()) == false)
         {
             qCWarning(KSTARS_EKOS_CAPTURE()) << "Cannot set ROI to " << "x =" << roi.x() << ", y =" << roi.y() << ", widht =" <<
                                              roi.width() << "height =" << roi.height();
             setStatus(JOB_ERROR);
             emit captureStarted(CaptureModuleState::CAPTURE_FRAME_ERROR);
         }
         else
             logentry.append(QString(", ROI = (%1+%2, %3+%4)").arg(roi.x()).arg(roi.width()).arg(roi.y()).arg(roi.width()));
     }
     else
         logentry.append(", Cannot subframe");
 
     // In case FITS Viewer is not enabled. Then for flat frames, we still need to keep the data
     // otherwise INDI CCD would simply discard loading the data in batch mode as the data are already
     // saved to disk and since no extra processing is required, FITSData is not loaded up with the data.
     // But in case of automatically calculated flat frames, we need FITSData.
     // Therefore, we need to explicitly set mode to FITS_CALIBRATE so that FITSData is generated.
     devices.data()->getActiveChip()->setCaptureMode(mode);
     devices.data()->getActiveChip()->setCaptureFilter(FITS_NONE);
 
     setStatus(getStatus());
 
     const auto exposure = getCoreProperty(SJ_Exposure).toDouble();
     m_ExposeLeft = exposure;
     devices.data()->getActiveChip()->capture(exposure);
     // create log entry with settings
     qCInfo(KSTARS_EKOS_CAPTURE()) << logentry;
 
     emit captureStarted(CaptureModuleState::CAPTURE_OK);
 }
 
 void SequenceJob::setTargetFilter(int pos, const QString &name)
 {
     state->targetFilterID = pos;
     setCoreProperty(SJ_Filter, name);
 }
 
 double SequenceJob::getExposeLeft() const
 {
     return m_ExposeLeft;
 }
 
 void SequenceJob::setExposeLeft(double value)
 {
     m_ExposeLeft = value;
 }
 
 
 int SequenceJob::getCaptureRetires() const
 {
     return m_CaptureRetires;
 }
 
 void SequenceJob::setCaptureRetires(int value)
 {
     m_CaptureRetires = value;
 }
 
 int SequenceJob::getCurrentFilter() const
 {
     return state->m_CaptureModuleState->currentFilterID;
 }
 
 ISD::Mount::PierSide SequenceJob::getPierSide() const
 {
     return state->m_CaptureModuleState->getPierSide();
 }
 
 // Setter: Set upload mode
 void SequenceJob::setUploadMode(ISD::Camera::UploadMode value)
 {
     m_UploadMode = value;
 }
 // Getter: get upload mode
 ISD::Camera::UploadMode SequenceJob::getUploadMode() const
 {
     return m_UploadMode;
 }
 
 // Setter: Set flat field source
 void SequenceJob::setCalibrationPreAction(uint32_t value)
 {
     state->m_CalibrationPreAction = value;
 }
 // Getter: Get calibration pre action
 uint32_t SequenceJob::getCalibrationPreAction() const
 {
     return state->m_CalibrationPreAction;
 }
 
 void SequenceJob::setWallCoord(const SkyPoint &value)
 {
     state->wallCoord = value;
 }
 
 const SkyPoint &SequenceJob::getWallCoord() const
 {
     return state->wallCoord;
 }
 
 // Setter: Set flat field duration
 void SequenceJob::setFlatFieldDuration(FlatFieldDuration value)
 {
     m_FlatFieldDuration = value;
 }
 
 // Getter: Get flat field duration
 FlatFieldDuration SequenceJob::getFlatFieldDuration() const
 {
     return m_FlatFieldDuration;
 }
 
 void SequenceJob::setJobProgressIgnored(bool value)
 {
     m_JobProgressIgnored = value;
 }
 
 bool SequenceJob::getJobProgressIgnored() const
 {
     return m_JobProgressIgnored;
 }
 
 void SequenceJob::updateDeviceStates()
 {
     setLightBox(devices->lightBox());
     addMount(devices->mount());
     setDome(devices->dome());
     setDustCap(devices->dustCap());
 }
 
 void SequenceJob::setLightBox(ISD::LightBox * lightBox)
 {
     state->m_CaptureModuleState->hasLightBox = (lightBox != nullptr);
 }
 
 void SequenceJob::setDustCap(ISD::DustCap * dustCap)
 {
     state->m_CaptureModuleState->hasDustCap = (dustCap != nullptr);
 }
 
 void SequenceJob::addMount(ISD::Mount * scope)
 {
     state->m_CaptureModuleState->hasTelescope = (scope != nullptr);
 }
 
 void SequenceJob::setDome(ISD::Dome * dome)
 {
     state->m_CaptureModuleState->hasDome = (dome != nullptr);
 }
 
 double SequenceJob::currentTemperature() const
 {
     return devices->cameraTemperature();
 }
 
 double SequenceJob::currentGain() const
 {
     return devices->cameraGain();
 }
 
 double SequenceJob::currentOffset() const
 {
     return devices->cameraOffset();
 }
 
 void SequenceJob::prepareCapture()
 {
     // simply forward it to the state machine
     switch (getFrameType())
     {
         case FRAME_LIGHT:
             state->prepareLightFrameCapture(getCoreProperty(SJ_EnforceTemperature).toBool(),
                                             jobType() == SequenceJob::JOBTYPE_PREVIEW);
             break;
         case FRAME_FLAT:
             state->prepareFlatFrameCapture(getCoreProperty(SJ_EnforceTemperature).toBool(),
                                            jobType() == SequenceJob::JOBTYPE_PREVIEW);
             break;
         case FRAME_DARK:
             state->prepareDarkFrameCapture(getCoreProperty(SJ_EnforceTemperature).toBool(),
                                            jobType() == SequenceJob::JOBTYPE_PREVIEW);
             break;
         case FRAME_BIAS:
             state->prepareBiasFrameCapture(getCoreProperty(SJ_EnforceTemperature).toBool(),
                                            jobType() == SequenceJob::JOBTYPE_PREVIEW);
             break;
         default:
             // not refactored yet, immediately completed
             processPrepareComplete();
             break;
     }
 }
 
 void SequenceJob::processPrepareComplete(bool success)
 {
     emit prepareComplete(success);
 }
 
 void SequenceJob::processAbortCapture()
 {
     disconnectDeviceAdaptor();
     emit abortCapture();
 }
 
 IPState SequenceJob::checkFlatFramePendingTasksCompleted()
 {
     // no further checks necessary
     return IPS_OK;
 }
 
 void SequenceJob::setCoreProperty(PropertyID id, const QVariant &value)
 {
     // Handle special cases
     switch (id)
     {
         case SJ_RemoteDirectory:
         {
             auto remoteDir = value.toString();
             if (remoteDir.endsWith('/'))
             {
                 remoteDir.chop(1);
                 m_CoreProperties[id] = remoteDir;
             }
         }
         break;
 
         default:
             break;
     }
     // store value
     m_CoreProperties[id] = value;
 }
 
 QVariant SequenceJob::getCoreProperty(PropertyID id) const
 {
     return m_CoreProperties[id];
 }
 
 void SequenceJob::loadFrom(XMLEle *root, const QString &targetName, SequenceJobType jobType,
                            QSharedPointer<CaptureModuleState> sharedState)
 {
     setJobType(jobType);
 
     // Set default property values
     m_CoreProperties[SJ_Exposure] = -1;
     m_CoreProperties[SJ_Gain] = -1;
     m_CoreProperties[SJ_Offset] = -1;
     m_CoreProperties[SJ_ISOIndex] = -1;
     m_CoreProperties[SJ_Count] = -1;
     m_CoreProperties[SJ_Delay] = -1;
     m_CoreProperties[SJ_Binning] = QPoint(1, 1);
     m_CoreProperties[SJ_ROI] = QRect(0, 0, 0, 0);
     m_CoreProperties[SJ_EnforceTemperature] = false;
     m_CoreProperties[SJ_GuiderActive] = false;
     m_CoreProperties[SJ_DitherPerJobFrequency] = 0;
     m_CoreProperties[SJ_Encoding] = "FITS";
 
     // targetName overrides values from the XML document
     if (targetName != "")
         setCoreProperty(SequenceJob::SJ_TargetName, targetName);
 
     if (root == nullptr)
         return;
 
     bool isDarkFlat = false;
 
     QLocale cLocale = QLocale::c();
     XMLEle * ep;
     XMLEle * subEP;
     for (ep = nextXMLEle(root, 1); ep != nullptr; ep = nextXMLEle(root, 0))
     {
         if (!strcmp(tagXMLEle(ep), "Exposure"))
             setCoreProperty(SequenceJob::SJ_Exposure, cLocale.toDouble(pcdataXMLEle(ep)));
         else if (!strcmp(tagXMLEle(ep), "Format"))
             setCoreProperty(SequenceJob::SJ_Format, pcdataXMLEle(ep));
         else if (!strcmp(tagXMLEle(ep), "Encoding"))
         {
             setCoreProperty(SequenceJob::SJ_Encoding, pcdataXMLEle(ep));
         }
         else if (!strcmp(tagXMLEle(ep), "Binning"))
         {
             QPoint binning(1, 1);
             subEP = findXMLEle(ep, "X");
             if (subEP)
                 binning.setX(cLocale.toInt(pcdataXMLEle(subEP)));
             subEP = findXMLEle(ep, "Y");
             if (subEP)
                 binning.setY(cLocale.toInt(pcdataXMLEle(subEP)));
 
             setCoreProperty(SequenceJob::SJ_Binning, binning);
         }
         else if (!strcmp(tagXMLEle(ep), "Frame"))
         {
             QRect roi(0, 0, 0, 0);
             subEP = findXMLEle(ep, "X");
             if (subEP)
                 roi.setX(cLocale.toInt(pcdataXMLEle(subEP)));
             subEP = findXMLEle(ep, "Y");
             if (subEP)
                 roi.setY(cLocale.toInt(pcdataXMLEle(subEP)));
             subEP = findXMLEle(ep, "W");
             if (subEP)
                 roi.setWidth(cLocale.toInt(pcdataXMLEle(subEP)));
             subEP = findXMLEle(ep, "H");
             if (subEP)
                 roi.setHeight(cLocale.toInt(pcdataXMLEle(subEP)));
 
             setCoreProperty(SequenceJob::SJ_ROI, roi);
         }
         else if (!strcmp(tagXMLEle(ep), "Temperature"))
         {
             setTargetTemperature(cLocale.toDouble(pcdataXMLEle(ep)));
 
             // If force attribute exist, we change cameraTemperatureS, otherwise do nothing.
             if (!strcmp(findXMLAttValu(ep, "force"), "true"))
                 setCoreProperty(SequenceJob::SJ_EnforceTemperature, true);
             else if (!strcmp(findXMLAttValu(ep, "force"), "false"))
                 setCoreProperty(SequenceJob::SJ_EnforceTemperature, false);
         }
         else if (!strcmp(tagXMLEle(ep), "Filter"))
         {
             const auto name = pcdataXMLEle(ep);
             const auto index = std::max(1, filterLabels().indexOf(name) + 1);
             setTargetFilter(index, name);
         }
         else if (!strcmp(tagXMLEle(ep), "Type"))
         {
             int index = frameTypes().indexOf(pcdataXMLEle(ep));
             setFrameType(static_cast<CCDFrameType>(qMax(0, index)));
         }
         else if (!strcmp(tagXMLEle(ep), "TargetName"))
         {
             auto jobTarget = pcdataXMLEle(ep);
 
             if (targetName == "")
                 // use the target from the XML document
                 setCoreProperty(SequenceJob::SJ_TargetName, jobTarget);
             else if (strcmp(jobTarget, "") != 0)
                 // issue a warning that target from the XML document is ignored
                 qWarning(KSTARS_EKOS_CAPTURE) << QString("Sequence job target name %1 ignored.").arg(jobTarget);
         }
         else if (!strcmp(tagXMLEle(ep), "Prefix"))
         {
             // RawPrefix is outdated and will be ignored
             subEP = findXMLEle(ep, "RawPrefix");
             if (subEP)
             {
                 auto jobTarget = pcdataXMLEle(subEP);
 
                 if (targetName == "")
                     // use the target from the XML document
                     setCoreProperty(SequenceJob::SJ_TargetName, jobTarget);
                 else if (strcmp(jobTarget, "") != 0)
                     // issue a warning that target from the XML document is ignored
                     qWarning(KSTARS_EKOS_CAPTURE) << QString("Sequence job raw prefix %1 ignored.").arg(jobTarget);
             }
             bool filterEnabled = false, expEnabled = false, tsEnabled = false;
             subEP = findXMLEle(ep, "FilterEnabled");
             if (subEP)
                 filterEnabled = !strcmp("1", pcdataXMLEle(subEP));
             subEP = findXMLEle(ep, "ExpEnabled");
             if (subEP)
                 expEnabled = !strcmp("1", pcdataXMLEle(subEP));
             subEP = findXMLEle(ep, "TimeStampEnabled");
             if (subEP)
                 tsEnabled = !strcmp("1", pcdataXMLEle(subEP));
             // build default format
             setCoreProperty(SequenceJob::SJ_PlaceholderFormat,
                             PlaceholderPath::defaultFormat(filterEnabled, expEnabled, tsEnabled));
         }
         else if (!strcmp(tagXMLEle(ep), "Count"))
         {
             setCoreProperty(SequenceJob::SJ_Count, cLocale.toInt(pcdataXMLEle(ep)));
         }
         else if (!strcmp(tagXMLEle(ep), "Delay"))
         {
             setCoreProperty(SequenceJob::SJ_Delay, cLocale.toInt(pcdataXMLEle(ep)) * 1000);
         }
         else if (!strcmp(tagXMLEle(ep), "PostCaptureScript"))
         {
             m_Scripts[SCRIPT_POST_CAPTURE] = pcdataXMLEle(ep);
         }
         else if (!strcmp(tagXMLEle(ep), "PreCaptureScript"))
         {
             m_Scripts[SCRIPT_PRE_CAPTURE] = pcdataXMLEle(ep);
         }
         else if (!strcmp(tagXMLEle(ep), "PostJobScript"))
         {
             m_Scripts[SCRIPT_POST_JOB] = pcdataXMLEle(ep);
         }
         else if (!strcmp(tagXMLEle(ep), "PreJobScript"))
         {
             m_Scripts[SCRIPT_PRE_JOB] = pcdataXMLEle(ep);
         }
         else if (!strcmp(tagXMLEle(ep), "GuideDitherPerJob"))
         {
             setCoreProperty(SequenceJob::SJ_DitherPerJobFrequency, cLocale.toInt(pcdataXMLEle(ep)));
         }
         else if (!strcmp(tagXMLEle(ep), "FITSDirectory"))
         {
             setCoreProperty(SequenceJob::SJ_LocalDirectory, pcdataXMLEle(ep));
         }
         else if (!strcmp(tagXMLEle(ep), "PlaceholderFormat"))
         {
             setCoreProperty(SequenceJob::SJ_PlaceholderFormat, pcdataXMLEle(ep));
         }
         else if (!strcmp(tagXMLEle(ep), "PlaceholderSuffix"))
         {
             setCoreProperty(SequenceJob::SJ_PlaceholderSuffix, cLocale.toUInt(pcdataXMLEle(ep)));
         }
         else if (!strcmp(tagXMLEle(ep), "RemoteDirectory"))
         {
             setCoreProperty(SequenceJob::SJ_RemoteDirectory, pcdataXMLEle(ep));
         }
         else if (!strcmp(tagXMLEle(ep), "UploadMode"))
         {
             setUploadMode(static_cast<ISD::Camera::UploadMode>(cLocale.toInt(pcdataXMLEle(ep))));
         }
         else if (!strcmp(tagXMLEle(ep), "ISOIndex"))
         {
             setISO(cLocale.toInt(pcdataXMLEle(ep)));
         }
         else if (!strcmp(tagXMLEle(ep), "Rotation"))
         {
             setTargetRotation(cLocale.toDouble(pcdataXMLEle(ep)));
         }
         else if (!strcmp(tagXMLEle(ep), "Properties"))
         {
             QMap<QString, QMap<QString, QVariant>> propertyMap;
 
             for (subEP = nextXMLEle(ep, 1); subEP != nullptr; subEP = nextXMLEle(ep, 0))
             {
                 QMap<QString, QVariant> elements;
                 XMLEle * oneElement = nullptr;
                 for (oneElement = nextXMLEle(subEP, 1); oneElement != nullptr; oneElement = nextXMLEle(subEP, 0))
                 {
                     const char * name = findXMLAttValu(oneElement, "name");
                     bool ok = false;
                     // String
                     auto xmlValue = pcdataXMLEle(oneElement);
                     // Try to load it as double
                     auto value = cLocale.toDouble(xmlValue, &ok);
                     if (ok)
                         elements[name] = value;
                     else
                         elements[name] = xmlValue;
                 }
 
                 const char * name = findXMLAttValu(subEP, "name");
                 propertyMap[name] = elements;
             }
 
             setCustomProperties(propertyMap);
             // read the gain and offset values from the custom properties
             setCoreProperty(SequenceJob::SJ_Gain, devices->cameraGain(propertyMap));
             setCoreProperty(SequenceJob::SJ_Offset, devices->cameraOffset(propertyMap));
         }
         else if (!strcmp(tagXMLEle(ep), "Calibration"))
         {
             // SQ_FORMAT_VERSION >= 2.7
             subEP = findXMLEle(ep, "PreAction");
             if (subEP)
             {
                 XMLEle * typeEP = findXMLEle(subEP, "Type");
                 if (typeEP)
                 {
                     setCalibrationPreAction(cLocale.toUInt(pcdataXMLEle(typeEP)));
                     if (getCalibrationPreAction() & ACTION_WALL)
                     {
                         XMLEle * azEP  = findXMLEle(subEP, "Az");
                         XMLEle * altEP = findXMLEle(subEP, "Alt");
 
                         if (azEP && altEP)
                         {
                             setCalibrationPreAction((getCalibrationPreAction() & ~ACTION_PARK_MOUNT) | ACTION_WALL);
                             SkyPoint wallCoord;
                             wallCoord.setAz(cLocale.toDouble(pcdataXMLEle(azEP)));
                             wallCoord.setAlt(cLocale.toDouble(pcdataXMLEle(altEP)));
                             setWallCoord(wallCoord);
                         }
                         else
                         {
                             qCWarning(KSTARS_EKOS_CAPTURE) << "Wall position coordinates missing, disabling slew to wall position action.";
                             setCalibrationPreAction((getCalibrationPreAction() & ~ACTION_WALL) | ACTION_NONE);
                         }
                     }
                 }
             }
 
             // SQ_FORMAT_VERSION < 2.7
             subEP = findXMLEle(ep, "FlatSource");
             if (subEP)
             {
                 XMLEle * typeEP = findXMLEle(subEP, "Type");
                 if (typeEP)
                 {
                     // default
                     setCalibrationPreAction(ACTION_NONE);
                     if (!strcmp(pcdataXMLEle(typeEP), "Wall"))
                     {
                         XMLEle * azEP  = findXMLEle(subEP, "Az");
                         XMLEle * altEP = findXMLEle(subEP, "Alt");
 
                         if (azEP && altEP)
                         {
                             setCalibrationPreAction((getCalibrationPreAction() & ~ACTION_PARK_MOUNT) | ACTION_WALL);
                             SkyPoint wallCoord;
                             wallCoord.setAz(cLocale.toDouble(pcdataXMLEle(azEP)));
                             wallCoord.setAlt(cLocale.toDouble(pcdataXMLEle(altEP)));
                             setWallCoord(wallCoord);
                         }
                     }
                 }
             }
 
             // SQ_FORMAT_VERSION < 2.7
             subEP = findXMLEle(ep, "PreMountPark");
             if (subEP && !strcmp(pcdataXMLEle(subEP), "True"))
                 setCalibrationPreAction(getCalibrationPreAction() | ACTION_PARK_MOUNT);
 
             // SQ_FORMAT_VERSION < 2.7
             subEP = findXMLEle(ep, "PreDomePark");
             if (subEP && !strcmp(pcdataXMLEle(subEP), "True"))
                 setCalibrationPreAction(getCalibrationPreAction() | ACTION_PARK_DOME);
 
             subEP = findXMLEle(ep, "FlatDuration");
             if (subEP)
             {
                 const char * dark = findXMLAttValu(subEP, "dark");
                 isDarkFlat = !strcmp(dark, "true");
 
                 XMLEle * typeEP = findXMLEle(subEP, "Type");
                 if (typeEP)
                 {
                     if (!strcmp(pcdataXMLEle(typeEP), "Manual"))
                         setFlatFieldDuration(DURATION_MANUAL);
                 }
 
                 XMLEle * aduEP = findXMLEle(subEP, "Value");
                 if (aduEP)
                 {
                     setFlatFieldDuration(DURATION_ADU);
                     setCoreProperty(SequenceJob::SJ_TargetADU, QVariant(cLocale.toDouble(pcdataXMLEle(aduEP))));
                 }
 
                 aduEP = findXMLEle(subEP, "Tolerance");
                 if (aduEP)
                 {
                     setCoreProperty(SequenceJob::SJ_TargetADUTolerance, QVariant(cLocale.toDouble(pcdataXMLEle(aduEP))));
                 }
             }
         }
     }
     if(isDarkFlat)
         setJobType(SequenceJob::JOBTYPE_DARKFLAT);
 }
 
 void SequenceJob::saveTo(QTextStream &outstream, const QLocale &cLocale) const
 {
     auto roi = getCoreProperty(SequenceJob::SJ_ROI).toRect();
 
     outstream << "<Job>" << Qt::endl;
 
     outstream << "<Exposure>" << cLocale.toString(getCoreProperty(SequenceJob::SJ_Exposure).toDouble()) << "</Exposure>" <<
               Qt::endl;
     outstream << "<Format>" << getCoreProperty(SequenceJob::SJ_Format).toString() << "</Format>" << Qt::endl;
     outstream << "<Encoding>" << getCoreProperty(SequenceJob::SJ_Encoding).toString() << "</Encoding>" << Qt::endl;
     outstream << "<Binning>" << Qt::endl;
     outstream << "<X>" << cLocale.toString(getCoreProperty(SequenceJob::SJ_Binning).toPoint().x()) << "</X>" << Qt::endl;
     outstream << "<Y>" << cLocale.toString(getCoreProperty(SequenceJob::SJ_Binning).toPoint().y()) << "</Y>" << Qt::endl;
     outstream << "</Binning>" << Qt::endl;
     outstream << "<Frame>" << Qt::endl;
     outstream << "<X>" << cLocale.toString(roi.x()) << "</X>" << Qt::endl;
     outstream << "<Y>" << cLocale.toString(roi.y()) << "</Y>" << Qt::endl;
     outstream << "<W>" << cLocale.toString(roi.width()) << "</W>" << Qt::endl;
     outstream << "<H>" << cLocale.toString(roi.height()) << "</H>" << Qt::endl;
     outstream << "</Frame>" << Qt::endl;
     if (getTargetTemperature() != Ekos::INVALID_VALUE)
         outstream << "<Temperature force='" << (getCoreProperty(SequenceJob::SJ_EnforceTemperature).toBool() ? "true" :
                                                 "false") << "'>"
                   << cLocale.toString(getTargetTemperature()) << "</Temperature>" << Qt::endl;
     if (getTargetFilter() >= 0)
         outstream << "<Filter>" << getCoreProperty(SequenceJob::SJ_Filter).toString() << "</Filter>" << Qt::endl;
     outstream << "<Type>" << frameTypes()[getFrameType()] << "</Type>" << Qt::endl;
     outstream << "<Count>" << cLocale.toString(getCoreProperty(SequenceJob::SJ_Count).toInt()) << "</Count>" << Qt::endl;
     // ms to seconds
     outstream << "<Delay>" << cLocale.toString(getCoreProperty(SequenceJob::SJ_Delay).toInt() / 1000.0) << "</Delay>" <<
               Qt::endl;
     if (getCoreProperty(SequenceJob::SJ_TargetName) != "")
         outstream << "<TargetName>" << getCoreProperty(SequenceJob::SJ_TargetName).toString() << "</TargetName>" << Qt::endl;
     if (getScript(SCRIPT_PRE_CAPTURE).isEmpty() == false)
         outstream << "<PreCaptureScript>" << getScript(SCRIPT_PRE_CAPTURE) << "</PreCaptureScript>" << Qt::endl;
     if (getScript(SCRIPT_POST_CAPTURE).isEmpty() == false)
         outstream << "<PostCaptureScript>" << getScript(SCRIPT_POST_CAPTURE) << "</PostCaptureScript>" << Qt::endl;
     if (getScript(SCRIPT_PRE_JOB).isEmpty() == false)
         outstream << "<PreJobScript>" << getScript(SCRIPT_PRE_JOB) << "</PreJobScript>" << Qt::endl;
     if (getScript(SCRIPT_POST_JOB).isEmpty() == false)
         outstream << "<PostJobScript>" << getScript(SCRIPT_POST_JOB) << "</PostJobScript>" << Qt::endl;
     outstream << "<GuideDitherPerJob>"
               << cLocale.toString(getCoreProperty(SequenceJob::SJ_DitherPerJobFrequency).toInt()) << "</GuideDitherPerJob>" <<
               Qt::endl;
     outstream << "<FITSDirectory>" << getCoreProperty(SequenceJob::SJ_LocalDirectory).toString() << "</FITSDirectory>" <<
               Qt::endl;
     outstream << "<PlaceholderFormat>" << getCoreProperty(SequenceJob::SJ_PlaceholderFormat).toString() <<
               "</PlaceholderFormat>" <<
               Qt::endl;
     outstream << "<PlaceholderSuffix>" << getCoreProperty(SequenceJob::SJ_PlaceholderSuffix).toUInt() <<
               "</PlaceholderSuffix>" <<
               Qt::endl;
     outstream << "<UploadMode>" << getUploadMode() << "</UploadMode>" << Qt::endl;
     if (getCoreProperty(SequenceJob::SJ_RemoteDirectory).toString().isEmpty() == false)
         outstream << "<RemoteDirectory>" << getCoreProperty(SequenceJob::SJ_RemoteDirectory).toString() << "</RemoteDirectory>"
                   << Qt::endl;
     if (getCoreProperty(SequenceJob::SJ_ISOIndex).toInt() != -1)
         outstream << "<ISOIndex>" << (getCoreProperty(SequenceJob::SJ_ISOIndex).toInt()) << "</ISOIndex>" << Qt::endl;
     if (getTargetRotation() != Ekos::INVALID_VALUE)
         outstream << "<Rotation>" << (getTargetRotation()) << "</Rotation>" << Qt::endl;
     QMapIterator<QString, QMap<QString, QVariant>> customIter(getCustomProperties());
     outstream << "<Properties>" << Qt::endl;
     while (customIter.hasNext())
     {
         customIter.next();
         outstream << "<PropertyVector name='" << customIter.key() << "'>" << Qt::endl;
         QMap<QString, QVariant> elements = customIter.value();
         QMapIterator<QString, QVariant> iter(elements);
         while (iter.hasNext())
         {
             iter.next();
             if (iter.value().type() == QVariant::String)
             {
                 outstream << "<OneElement name='" << iter.key()
                           << "'>" << iter.value().toString() << "</OneElement>" << Qt::endl;
             }
             else
             {
                 outstream << "<OneElement name='" << iter.key()
                           << "'>" << iter.value().toDouble() << "</OneElement>" << Qt::endl;
             }
         }
         outstream << "</PropertyVector>" << Qt::endl;
     }
     outstream << "</Properties>" << Qt::endl;
 
     outstream << "<Calibration>" << Qt::endl;
     outstream << "<PreAction>" << Qt::endl;
     outstream << QString("<Type>%1</Type>").arg(getCalibrationPreAction()) << Qt::endl;
     if (getCalibrationPreAction() & ACTION_WALL)
     {
         outstream << "<Az>" << cLocale.toString(getWallCoord().az().Degrees()) << "</Az>" << Qt::endl;
         outstream << "<Alt>" << cLocale.toString(getWallCoord().alt().Degrees()) << "</Alt>" << Qt::endl;
     }
     outstream << "</PreAction>" << Qt::endl;
 
     outstream << "<FlatDuration dark='" << (jobType() == SequenceJob::JOBTYPE_DARKFLAT ? "true" : "false")
               << "'>" << Qt::endl;
     if (getFlatFieldDuration() == DURATION_MANUAL)
         outstream << "<Type>Manual</Type>" << Qt::endl;
     else
     {
         outstream << "<Type>ADU</Type>" << Qt::endl;
         outstream << "<Value>" << cLocale.toString(getCoreProperty(SequenceJob::SJ_TargetADU).toDouble()) << "</Value>" <<
                   Qt::endl;
         outstream << "<Tolerance>" << cLocale.toString(getCoreProperty(SequenceJob::SJ_TargetADUTolerance).toDouble()) <<
                   "</Tolerance>" << Qt::endl;
     }
     outstream << "</FlatDuration>" << Qt::endl;
     outstream << "</Calibration>" << Qt::endl;
     outstream << "</Job>" << Qt::endl;
 }
 }