/********************************************************************************
** Form generated from reading UI file 'opsguide.ui'
**
** Created by: Qt User Interface Compiler version 6.11.1
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/

#ifndef UI_OPSGUIDE_H
#define UI_OPSGUIDE_H

#include <QtCore/QVariant>
#include <QtWidgets/QApplication>
#include <QtWidgets/QCheckBox>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QDoubleSpinBox>
#include <QtWidgets/QFrame>
#include <QtWidgets/QGridLayout>
#include <QtWidgets/QGroupBox>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QLabel>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QSpacerItem>
#include <QtWidgets/QSpinBox>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QWidget>
#include <klocalizedstring.h>

QT_BEGIN_NAMESPACE

class Ui_OpsGuide
{
public:
    QVBoxLayout *verticalLayout_2;
    QGroupBox *controlGroup;
    QHBoxLayout *horizontalLayout_1;
    QVBoxLayout *verticalLayout_3;
    QFrame *line;
    QGridLayout *gridLayout_3;
    QLabel *AlgLabel;
    QComboBox *kcfg_RAGuidePulseAlgorithm;
    QComboBox *kcfg_DECGuidePulseAlgorithm;
    QLabel *l_12;
    QDoubleSpinBox *kcfg_RAProportionalGain;
    QLabel *l_11;
    QDoubleSpinBox *kcfg_DECProportionalGain;
    QLabel *l_02;
    QLabel *l_01;
    QLabel *l_14;
    QDoubleSpinBox *kcfg_RAMinimumPulseArcSec;
    QDoubleSpinBox *kcfg_RAIntegralGain;
    QLabel *l_15;
    QDoubleSpinBox *kcfg_DECIntegralGain;
    QSpinBox *kcfg_DECMaximumPulseArcSec;
    QSpinBox *kcfg_RAMaximumPulseArcSec;
    QDoubleSpinBox *kcfg_DECMinimumPulseArcSec;
    QLabel *HysteresisGuiderLabel;
    QDoubleSpinBox *kcfg_RAHysteresis;
    QDoubleSpinBox *kcfg_DECHysteresis;
    QSpacerItem *hSpacer;
    QSpacerItem *verticalSpacer_2;
    QHBoxLayout *horizontalLayout_2;
    QGroupBox *groupBox;
    QGridLayout *gridLayout_2;
    QLabel *label_17;
    QDoubleSpinBox *kcfg_GuideMaxDeltaRMS;
    QLabel *label_11;
    QLabel *label_13;
    QLabel *label_24;
    QLabel *l_20;
    QDoubleSpinBox *kcfg_GuideMaxHFR;
    QLabel *label_20;
    QSpinBox *kcfg_GuideLostStarTimeout;
    QLabel *label_12;
    QLabel *label_14;
    QCheckBox *kcfg_AlwaysInventGuideStar;
    QCheckBox *kcfg_SaveGuideLog;
    QLabel *label_23;
    QComboBox *kcfg_GuideAlgorithm;
    QLabel *l_19;
    QComboBox *kcfg_GuideOptionsProfile;
    QLabel *label_21;
    QPushButton *editGuideProfile;
    QSpinBox *kcfg_MinDetectionsSEPMultistar;
    QLabel *label_25;
    QSpinBox *kcfg_MaxMultistarReferenceStars;
    QSpinBox *kcfg_GuideCalibrationTimeout;
    QLabel *label_22;
    QLabel *label_16;
    QCheckBox *kcfg_UseGuideHead;
    QSpacerItem *hSpacer2;
    QSpacerItem *verticalSpacer;

    void setupUi(QWidget *OpsGuide)
    {
        if (OpsGuide->objectName().isEmpty())
            OpsGuide->setObjectName("OpsGuide");
        OpsGuide->resize(372, 604);
        verticalLayout_2 = new QVBoxLayout(OpsGuide);
        verticalLayout_2->setSpacing(3);
        verticalLayout_2->setObjectName("verticalLayout_2");
        verticalLayout_2->setContentsMargins(3, 3, 3, 3);
        controlGroup = new QGroupBox(OpsGuide);
        controlGroup->setObjectName("controlGroup");
        horizontalLayout_1 = new QHBoxLayout(controlGroup);
        horizontalLayout_1->setObjectName("horizontalLayout_1");
        verticalLayout_3 = new QVBoxLayout();
        verticalLayout_3->setSpacing(3);
        verticalLayout_3->setObjectName("verticalLayout_3");
        verticalLayout_3->setContentsMargins(0, 0, 0, 0);
        line = new QFrame(controlGroup);
        line->setObjectName("line");
        line->setFrameShape(QFrame::Shape::HLine);
        line->setFrameShadow(QFrame::Shadow::Sunken);

        verticalLayout_3->addWidget(line);

        gridLayout_3 = new QGridLayout();
        gridLayout_3->setObjectName("gridLayout_3");
        gridLayout_3->setHorizontalSpacing(1);
        gridLayout_3->setVerticalSpacing(5);
        AlgLabel = new QLabel(controlGroup);
        AlgLabel->setObjectName("AlgLabel");

        gridLayout_3->addWidget(AlgLabel, 1, 0, 1, 1);

        kcfg_RAGuidePulseAlgorithm = new QComboBox(controlGroup);
        kcfg_RAGuidePulseAlgorithm->addItem(QString());
        kcfg_RAGuidePulseAlgorithm->addItem(QString());
        kcfg_RAGuidePulseAlgorithm->addItem(QString());
        kcfg_RAGuidePulseAlgorithm->addItem(QString());
        kcfg_RAGuidePulseAlgorithm->addItem(QString());
        kcfg_RAGuidePulseAlgorithm->setObjectName("kcfg_RAGuidePulseAlgorithm");
        QSizePolicy sizePolicy(QSizePolicy::Policy::Preferred, QSizePolicy::Policy::Fixed);
        sizePolicy.setHorizontalStretch(0);
        sizePolicy.setVerticalStretch(0);
        sizePolicy.setHeightForWidth(kcfg_RAGuidePulseAlgorithm->sizePolicy().hasHeightForWidth());
        kcfg_RAGuidePulseAlgorithm->setSizePolicy(sizePolicy);

        gridLayout_3->addWidget(kcfg_RAGuidePulseAlgorithm, 1, 1, 1, 1);

        kcfg_DECGuidePulseAlgorithm = new QComboBox(controlGroup);
        kcfg_DECGuidePulseAlgorithm->addItem(QString());
        kcfg_DECGuidePulseAlgorithm->addItem(QString());
        kcfg_DECGuidePulseAlgorithm->addItem(QString());
        kcfg_DECGuidePulseAlgorithm->addItem(QString());
        kcfg_DECGuidePulseAlgorithm->setObjectName("kcfg_DECGuidePulseAlgorithm");
        sizePolicy.setHeightForWidth(kcfg_DECGuidePulseAlgorithm->sizePolicy().hasHeightForWidth());
        kcfg_DECGuidePulseAlgorithm->setSizePolicy(sizePolicy);

        gridLayout_3->addWidget(kcfg_DECGuidePulseAlgorithm, 1, 2, 1, 1);

        l_12 = new QLabel(controlGroup);
        l_12->setObjectName("l_12");

        gridLayout_3->addWidget(l_12, 3, 0, 1, 1);

        kcfg_RAProportionalGain = new QDoubleSpinBox(controlGroup);
        kcfg_RAProportionalGain->setObjectName("kcfg_RAProportionalGain");
        kcfg_RAProportionalGain->setDecimals(2);
        kcfg_RAProportionalGain->setMaximum(1.000000000000000);
        kcfg_RAProportionalGain->setSingleStep(0.050000000000000);
        kcfg_RAProportionalGain->setValue(0.750000000000000);

        gridLayout_3->addWidget(kcfg_RAProportionalGain, 2, 1, 1, 1);

        l_11 = new QLabel(controlGroup);
        l_11->setObjectName("l_11");
        l_11->setMargin(0);
        l_11->setIndent(0);

        gridLayout_3->addWidget(l_11, 2, 0, 1, 1);

        kcfg_DECProportionalGain = new QDoubleSpinBox(controlGroup);
        kcfg_DECProportionalGain->setObjectName("kcfg_DECProportionalGain");
        kcfg_DECProportionalGain->setDecimals(2);
        kcfg_DECProportionalGain->setMaximum(1.000000000000000);
        kcfg_DECProportionalGain->setSingleStep(0.050000000000000);
        kcfg_DECProportionalGain->setValue(0.750000000000000);

        gridLayout_3->addWidget(kcfg_DECProportionalGain, 2, 2, 1, 1);

        l_02 = new QLabel(controlGroup);
        l_02->setObjectName("l_02");
        l_02->setAlignment(Qt::AlignCenter);

        gridLayout_3->addWidget(l_02, 0, 2, 1, 1);

        l_01 = new QLabel(controlGroup);
        l_01->setObjectName("l_01");
        l_01->setAlignment(Qt::AlignCenter);

        gridLayout_3->addWidget(l_01, 0, 1, 1, 1);

        l_14 = new QLabel(controlGroup);
        l_14->setObjectName("l_14");
        l_14->setContentsMargins(-1, -1, 5, -1);

        gridLayout_3->addWidget(l_14, 5, 0, 1, 1);

        kcfg_RAMinimumPulseArcSec = new QDoubleSpinBox(controlGroup);
        kcfg_RAMinimumPulseArcSec->setObjectName("kcfg_RAMinimumPulseArcSec");
        kcfg_RAMinimumPulseArcSec->setDecimals(2);
        kcfg_RAMinimumPulseArcSec->setMaximum(1000.000000000000000);
        kcfg_RAMinimumPulseArcSec->setSingleStep(0.100000000000000);

        gridLayout_3->addWidget(kcfg_RAMinimumPulseArcSec, 4, 1, 1, 1);

        kcfg_RAIntegralGain = new QDoubleSpinBox(controlGroup);
        kcfg_RAIntegralGain->setObjectName("kcfg_RAIntegralGain");
        kcfg_RAIntegralGain->setDecimals(2);
        kcfg_RAIntegralGain->setMaximum(1.000000000000000);
        kcfg_RAIntegralGain->setSingleStep(0.050000000000000);

        gridLayout_3->addWidget(kcfg_RAIntegralGain, 3, 1, 1, 1);

        l_15 = new QLabel(controlGroup);
        l_15->setObjectName("l_15");
        l_15->setContentsMargins(-1, -1, 5, -1);

        gridLayout_3->addWidget(l_15, 4, 0, 1, 1);

        kcfg_DECIntegralGain = new QDoubleSpinBox(controlGroup);
        kcfg_DECIntegralGain->setObjectName("kcfg_DECIntegralGain");
        kcfg_DECIntegralGain->setDecimals(2);
        kcfg_DECIntegralGain->setMaximum(1.000000000000000);
        kcfg_DECIntegralGain->setSingleStep(0.050000000000000);

        gridLayout_3->addWidget(kcfg_DECIntegralGain, 3, 2, 1, 1);

        kcfg_DECMaximumPulseArcSec = new QSpinBox(controlGroup);
        kcfg_DECMaximumPulseArcSec->setObjectName("kcfg_DECMaximumPulseArcSec");
        kcfg_DECMaximumPulseArcSec->setMaximum(3600);
        kcfg_DECMaximumPulseArcSec->setSingleStep(10);

        gridLayout_3->addWidget(kcfg_DECMaximumPulseArcSec, 5, 2, 1, 1);

        kcfg_RAMaximumPulseArcSec = new QSpinBox(controlGroup);
        kcfg_RAMaximumPulseArcSec->setObjectName("kcfg_RAMaximumPulseArcSec");
        kcfg_RAMaximumPulseArcSec->setMaximum(3600);
        kcfg_RAMaximumPulseArcSec->setSingleStep(10);

        gridLayout_3->addWidget(kcfg_RAMaximumPulseArcSec, 5, 1, 1, 1);

        kcfg_DECMinimumPulseArcSec = new QDoubleSpinBox(controlGroup);
        kcfg_DECMinimumPulseArcSec->setObjectName("kcfg_DECMinimumPulseArcSec");
        kcfg_DECMinimumPulseArcSec->setDecimals(2);
        kcfg_DECMinimumPulseArcSec->setMaximum(1000.000000000000000);
        kcfg_DECMinimumPulseArcSec->setSingleStep(0.100000000000000);

        gridLayout_3->addWidget(kcfg_DECMinimumPulseArcSec, 4, 2, 1, 1);

        HysteresisGuiderLabel = new QLabel(controlGroup);
        HysteresisGuiderLabel->setObjectName("HysteresisGuiderLabel");

        gridLayout_3->addWidget(HysteresisGuiderLabel, 6, 0, 1, 1);

        kcfg_RAHysteresis = new QDoubleSpinBox(controlGroup);
        kcfg_RAHysteresis->setObjectName("kcfg_RAHysteresis");
        kcfg_RAHysteresis->setDecimals(2);
        kcfg_RAHysteresis->setMaximum(0.900000000000000);
        kcfg_RAHysteresis->setSingleStep(0.100000000000000);
        kcfg_RAHysteresis->setMinimum(0.000000000000000);
        kcfg_RAHysteresis->setValue(0.000000000000000);

        gridLayout_3->addWidget(kcfg_RAHysteresis, 6, 1, 1, 1);

        kcfg_DECHysteresis = new QDoubleSpinBox(controlGroup);
        kcfg_DECHysteresis->setObjectName("kcfg_DECHysteresis");
        kcfg_DECHysteresis->setDecimals(2);
        kcfg_DECHysteresis->setMaximum(0.900000000000000);
        kcfg_DECHysteresis->setSingleStep(0.100000000000000);
        kcfg_DECHysteresis->setMinimum(0.000000000000000);
        kcfg_DECHysteresis->setValue(0.000000000000000);

        gridLayout_3->addWidget(kcfg_DECHysteresis, 6, 2, 1, 1);

        gridLayout_3->setColumnStretch(0, 1);

        verticalLayout_3->addLayout(gridLayout_3);


        horizontalLayout_1->addLayout(verticalLayout_3);

        hSpacer = new QSpacerItem(0, 0, QSizePolicy::Policy::Expanding, QSizePolicy::Policy::Minimum);

        horizontalLayout_1->addItem(hSpacer);


        verticalLayout_2->addWidget(controlGroup);

        verticalSpacer_2 = new QSpacerItem(20, 15, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::Fixed);

        verticalLayout_2->addItem(verticalSpacer_2);

        horizontalLayout_2 = new QHBoxLayout();
        horizontalLayout_2->setObjectName("horizontalLayout_2");
        groupBox = new QGroupBox(OpsGuide);
        groupBox->setObjectName("groupBox");
        gridLayout_2 = new QGridLayout(groupBox);
        gridLayout_2->setSpacing(3);
        gridLayout_2->setObjectName("gridLayout_2");
        gridLayout_2->setContentsMargins(3, 3, 3, 3);
        label_17 = new QLabel(groupBox);
        label_17->setObjectName("label_17");

        gridLayout_2->addWidget(label_17, 4, 3, 1, 1);

        kcfg_GuideMaxDeltaRMS = new QDoubleSpinBox(groupBox);
        kcfg_GuideMaxDeltaRMS->setObjectName("kcfg_GuideMaxDeltaRMS");
        kcfg_GuideMaxDeltaRMS->setMinimum(0.500000000000000);
        kcfg_GuideMaxDeltaRMS->setMaximum(30.000000000000000);
        kcfg_GuideMaxDeltaRMS->setValue(10.000000000000000);

        gridLayout_2->addWidget(kcfg_GuideMaxDeltaRMS, 5, 2, 1, 1);

        label_11 = new QLabel(groupBox);
        label_11->setObjectName("label_11");

        gridLayout_2->addWidget(label_11, 2, 0, 1, 2);

        label_13 = new QLabel(groupBox);
        label_13->setObjectName("label_13");

        gridLayout_2->addWidget(label_13, 5, 0, 1, 2);

        label_24 = new QLabel(groupBox);
        label_24->setObjectName("label_24");

        gridLayout_2->addWidget(label_24, 8, 0, 1, 2);

        l_20 = new QLabel(groupBox);
        l_20->setObjectName("l_20");

        gridLayout_2->addWidget(l_20, 1, 0, 1, 1);

        kcfg_GuideMaxHFR = new QDoubleSpinBox(groupBox);
        kcfg_GuideMaxHFR->setObjectName("kcfg_GuideMaxHFR");
        kcfg_GuideMaxHFR->setMinimum(0.500000000000000);
        kcfg_GuideMaxHFR->setMaximum(20.000000000000000);
        kcfg_GuideMaxHFR->setValue(4.500000000000000);

        gridLayout_2->addWidget(kcfg_GuideMaxHFR, 6, 2, 1, 1);

        label_20 = new QLabel(groupBox);
        label_20->setObjectName("label_20");

        gridLayout_2->addWidget(label_20, 6, 0, 1, 2);

        kcfg_GuideLostStarTimeout = new QSpinBox(groupBox);
        kcfg_GuideLostStarTimeout->setObjectName("kcfg_GuideLostStarTimeout");
        kcfg_GuideLostStarTimeout->setMaximum(3600);
        kcfg_GuideLostStarTimeout->setSingleStep(10);
        kcfg_GuideLostStarTimeout->setValue(60);

        gridLayout_2->addWidget(kcfg_GuideLostStarTimeout, 2, 2, 1, 1);

        label_12 = new QLabel(groupBox);
        label_12->setObjectName("label_12");

        gridLayout_2->addWidget(label_12, 2, 3, 1, 1);

        label_14 = new QLabel(groupBox);
        label_14->setObjectName("label_14");

        gridLayout_2->addWidget(label_14, 5, 3, 1, 1);

        kcfg_AlwaysInventGuideStar = new QCheckBox(groupBox);
        kcfg_AlwaysInventGuideStar->setObjectName("kcfg_AlwaysInventGuideStar");
        kcfg_AlwaysInventGuideStar->setEnabled(true);

        gridLayout_2->addWidget(kcfg_AlwaysInventGuideStar, 9, 0, 1, 4);

        kcfg_SaveGuideLog = new QCheckBox(groupBox);
        kcfg_SaveGuideLog->setObjectName("kcfg_SaveGuideLog");
        kcfg_SaveGuideLog->setEnabled(true);

        gridLayout_2->addWidget(kcfg_SaveGuideLog, 11, 0, 1, 4);

        label_23 = new QLabel(groupBox);
        label_23->setObjectName("label_23");

        gridLayout_2->addWidget(label_23, 7, 3, 1, 1);

        kcfg_GuideAlgorithm = new QComboBox(groupBox);
        kcfg_GuideAlgorithm->addItem(QString());
        kcfg_GuideAlgorithm->addItem(QString());
        kcfg_GuideAlgorithm->addItem(QString());
        kcfg_GuideAlgorithm->addItem(QString());
        kcfg_GuideAlgorithm->addItem(QString());
        kcfg_GuideAlgorithm->addItem(QString());
        kcfg_GuideAlgorithm->setObjectName("kcfg_GuideAlgorithm");
        sizePolicy.setHeightForWidth(kcfg_GuideAlgorithm->sizePolicy().hasHeightForWidth());
        kcfg_GuideAlgorithm->setSizePolicy(sizePolicy);

        gridLayout_2->addWidget(kcfg_GuideAlgorithm, 0, 1, 1, 3);

        l_19 = new QLabel(groupBox);
        l_19->setObjectName("l_19");

        gridLayout_2->addWidget(l_19, 0, 0, 1, 1);

        kcfg_GuideOptionsProfile = new QComboBox(groupBox);
        kcfg_GuideOptionsProfile->setObjectName("kcfg_GuideOptionsProfile");
        sizePolicy.setHeightForWidth(kcfg_GuideOptionsProfile->sizePolicy().hasHeightForWidth());
        kcfg_GuideOptionsProfile->setSizePolicy(sizePolicy);

        gridLayout_2->addWidget(kcfg_GuideOptionsProfile, 1, 1, 1, 2);

        label_21 = new QLabel(groupBox);
        label_21->setObjectName("label_21");

        gridLayout_2->addWidget(label_21, 6, 3, 1, 1);

        editGuideProfile = new QPushButton(groupBox);
        editGuideProfile->setObjectName("editGuideProfile");
        editGuideProfile->setMaximumSize(QSize(22, 22));

        gridLayout_2->addWidget(editGuideProfile, 1, 3, 1, 1);

        kcfg_MinDetectionsSEPMultistar = new QSpinBox(groupBox);
        kcfg_MinDetectionsSEPMultistar->setObjectName("kcfg_MinDetectionsSEPMultistar");
        kcfg_MinDetectionsSEPMultistar->setMinimum(1);
        kcfg_MinDetectionsSEPMultistar->setMaximum(20);
        kcfg_MinDetectionsSEPMultistar->setSingleStep(1);

        gridLayout_2->addWidget(kcfg_MinDetectionsSEPMultistar, 7, 2, 1, 1);

        label_25 = new QLabel(groupBox);
        label_25->setObjectName("label_25");

        gridLayout_2->addWidget(label_25, 8, 3, 1, 1);

        kcfg_MaxMultistarReferenceStars = new QSpinBox(groupBox);
        kcfg_MaxMultistarReferenceStars->setObjectName("kcfg_MaxMultistarReferenceStars");
        kcfg_MaxMultistarReferenceStars->setMinimum(1);
        kcfg_MaxMultistarReferenceStars->setMaximum(100);
        kcfg_MaxMultistarReferenceStars->setSingleStep(1);
        kcfg_MaxMultistarReferenceStars->setValue(50);

        gridLayout_2->addWidget(kcfg_MaxMultistarReferenceStars, 8, 2, 1, 1);

        kcfg_GuideCalibrationTimeout = new QSpinBox(groupBox);
        kcfg_GuideCalibrationTimeout->setObjectName("kcfg_GuideCalibrationTimeout");
        kcfg_GuideCalibrationTimeout->setMaximum(3600);
        kcfg_GuideCalibrationTimeout->setValue(300);

        gridLayout_2->addWidget(kcfg_GuideCalibrationTimeout, 4, 2, 1, 1);

        label_22 = new QLabel(groupBox);
        label_22->setObjectName("label_22");

        gridLayout_2->addWidget(label_22, 7, 0, 1, 2);

        label_16 = new QLabel(groupBox);
        label_16->setObjectName("label_16");
        QSizePolicy sizePolicy1(QSizePolicy::Policy::Preferred, QSizePolicy::Policy::Preferred);
        sizePolicy1.setHorizontalStretch(0);
        sizePolicy1.setVerticalStretch(0);
        sizePolicy1.setHeightForWidth(label_16->sizePolicy().hasHeightForWidth());
        label_16->setSizePolicy(sizePolicy1);

        gridLayout_2->addWidget(label_16, 4, 0, 1, 2);

        kcfg_UseGuideHead = new QCheckBox(groupBox);
        kcfg_UseGuideHead->setObjectName("kcfg_UseGuideHead");

        gridLayout_2->addWidget(kcfg_UseGuideHead, 10, 0, 1, 4);


        horizontalLayout_2->addWidget(groupBox);

        hSpacer2 = new QSpacerItem(0, 0, QSizePolicy::Policy::Expanding, QSizePolicy::Policy::Minimum);

        horizontalLayout_2->addItem(hSpacer2);


        verticalLayout_2->addLayout(horizontalLayout_2);

        verticalSpacer = new QSpacerItem(20, 40, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::Expanding);

        verticalLayout_2->addItem(verticalSpacer);

        QWidget::setTabOrder(kcfg_RAProportionalGain, kcfg_DECProportionalGain);
        QWidget::setTabOrder(kcfg_DECProportionalGain, kcfg_RAIntegralGain);
        QWidget::setTabOrder(kcfg_RAIntegralGain, kcfg_DECIntegralGain);
        QWidget::setTabOrder(kcfg_DECIntegralGain, kcfg_RAMinimumPulseArcSec);
        QWidget::setTabOrder(kcfg_RAMinimumPulseArcSec, kcfg_DECMinimumPulseArcSec);
        QWidget::setTabOrder(kcfg_DECMinimumPulseArcSec, kcfg_RAMaximumPulseArcSec);
        QWidget::setTabOrder(kcfg_RAMaximumPulseArcSec, kcfg_DECMaximumPulseArcSec);
        QWidget::setTabOrder(kcfg_DECMaximumPulseArcSec, kcfg_GuideAlgorithm);
        QWidget::setTabOrder(kcfg_GuideAlgorithm, kcfg_GuideOptionsProfile);
        QWidget::setTabOrder(kcfg_GuideOptionsProfile, editGuideProfile);
        QWidget::setTabOrder(editGuideProfile, kcfg_GuideLostStarTimeout);
        QWidget::setTabOrder(kcfg_GuideLostStarTimeout, kcfg_GuideCalibrationTimeout);
        QWidget::setTabOrder(kcfg_GuideCalibrationTimeout, kcfg_GuideMaxDeltaRMS);
        QWidget::setTabOrder(kcfg_GuideMaxDeltaRMS, kcfg_GuideMaxHFR);
        QWidget::setTabOrder(kcfg_GuideMaxHFR, kcfg_SaveGuideLog);

        retranslateUi(OpsGuide);

        kcfg_RAGuidePulseAlgorithm->setCurrentIndex(0);
        kcfg_DECGuidePulseAlgorithm->setCurrentIndex(0);
        kcfg_GuideAlgorithm->setCurrentIndex(5);


        QMetaObject::connectSlotsByName(OpsGuide);
    } // setupUi

    void retranslateUi(QWidget *OpsGuide)
    {
        controlGroup->setTitle(tr2i18n("Control Parameters", nullptr));
#if QT_CONFIG(tooltip)
        AlgLabel->setToolTip(tr2i18n("The algorithm that computes the guide correction pulses.", nullptr));
#endif // QT_CONFIG(tooltip)
        AlgLabel->setText(tr2i18n("Guiding Algorithm", nullptr));
#if QT_CONFIG(tooltip)
        AlgLabel->setToolTip(tr2i18n("<html><head/><body><p>Select the guide pulse algorithms for RA and DEC.</p><ul style=\"margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;\"><li style=\" margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Standard</span>: The traditional proportional guide algorithm. It computes a pulse to correct the computed guide drift. The aggressiveness parameter decides what proportion of the error is corrected. Errors smaller than MinError won't be corrected. Max response limits the largest correction. The hysteresis parameter is not used.</li><li style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Hysteresis</span>: Hysteresis is like the standard algorithm but weights in the previous correction according to the hysteresis parameter. Integral gain does not apply.</li><li style=\" margin-t"
                        "op:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Linear</span>: This is similar to the PHD2 Lowpass2 algorithm. It computes the error pulses based on a short history of recent errors. This may be applicable to very stable mounts. Hysteresis and Integral gain do not apply.</li><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">GPG</span>: (RA Only) The GPG algorithm tries to predict periodic error and linear drifts. It uses the aggressiveness, min and max parameters here, and more parameters on the separate GPG tab. Hysteresis and Integral gain do not apply.</li></ul></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        kcfg_RAGuidePulseAlgorithm->setItemText(0, tr2i18n("Standard", nullptr));
        kcfg_RAGuidePulseAlgorithm->setItemText(1, tr2i18n("Hysteresis", nullptr));
        kcfg_RAGuidePulseAlgorithm->setItemText(2, tr2i18n("Linear", nullptr));
        kcfg_RAGuidePulseAlgorithm->setItemText(3, tr2i18n("GPG", nullptr));
        kcfg_RAGuidePulseAlgorithm->setItemText(4, tr2i18n("AI Guider", nullptr));

#if QT_CONFIG(tooltip)
        kcfg_RAGuidePulseAlgorithm->setToolTip(tr2i18n("<html><head/><body><p>Select the guide pulse algorithms for RA.</p><ul style=\"margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;\"><li style=\" margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Standard</span>: The traditional proportional guide algorithm. It computes a pulse to correct the computed guide drift. The aggressiveness parameter decides what proportion of the error is corrected. Errors smaller than MinError won't be corrected. Max response limits the largest correction. The hysteresis parameter is not used.</li><li style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Hysteresis</span>: Hysteresis is like the standard algorithm but weights in the previous correction according to the hysteresis parameter. Integral gain does not apply.</li><li style=\" margin-top:0px; "
                        "margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Linear</span>: This is similar to the PHD2 Lowpass2 algorithm. It computes the error pulses based on a short history of recent errors. This may be applicable to very stable mounts. Hysteresis and Integral gain do not apply.</li><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">GPG</span>: The GPG algorithm tries to predict periodic error and linear drifts. It uses the aggressiveness, min and max parameters here, and more parameters on the separate GPG tab. Hysteresis and Integral gain do not apply.</li></ul></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        kcfg_DECGuidePulseAlgorithm->setItemText(0, tr2i18n("Standard", nullptr));
        kcfg_DECGuidePulseAlgorithm->setItemText(1, tr2i18n("Hysteresis", nullptr));
        kcfg_DECGuidePulseAlgorithm->setItemText(2, tr2i18n("Linear", nullptr));
        kcfg_DECGuidePulseAlgorithm->setItemText(3, tr2i18n("AI Guider", nullptr));

#if QT_CONFIG(tooltip)
        kcfg_DECGuidePulseAlgorithm->setToolTip(tr2i18n("<html><head/><body><p>Select the guide pulse algorithms for DEC.</p><ul style=\"margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;\"><li style=\" margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Standard</span>: The traditional proportional guide algorithm. It computes a pulse to correct the computed guide drift. The aggressiveness parameter decides what proportion of the error is corrected. Errors smaller than MinError won't be corrected. Max response limits the largest correction. The hysteresis parameter is not used.</li><li style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Hysteresis</span>: Hysteresis is like the standard algorithm but weights in the previous correction according to the hysteresis parameter. Integral gain does not apply.</li><li style=\" margin-top:0px;"
                        " margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Linear</span>: This is similar to the PHD2 Lowpass2 algorithm. It computes the error pulses based on a short history of recent errors. This may be applicable to very stable mounts. Hysteresis and Integral gain do not apply.</li></ul></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        l_12->setToolTip(tr2i18n("<html><head/><body><p>This adds a correction term based on the average of the past 50 guide deviations. For example, if the deviation is consistently negative, this will attempt to compensate. Best to start with 0.0 (no effect) and only use this if necessary. (Only applies to the standard algorithm.)</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        l_12->setText(tr2i18n("Integral gain (deprecated)", nullptr));
#if QT_CONFIG(tooltip)
        l_11->setToolTip(tr2i18n("<html><head/><body><p>How aggressively the guider attempts to correct the guide deviations. 1.0 would attempt to fully correct the error. It's best to use an aggressiveness less than 1.0 to avoid oscillations.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        l_11->setText(tr2i18n("Aggressiveness (0-1.0)", nullptr));
        l_02->setText(tr2i18n("DEC", nullptr));
        l_01->setText(tr2i18n("RA", nullptr));
#if QT_CONFIG(tooltip)
        l_14->setToolTip(tr2i18n("<html><head/><body><p>Maximum guide pulse that is generated by the guider and sent to the mount in arc-second units. That is, the guider will not attempt to move the mount more than this many arc-seconds at any given time.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        l_14->setText(tr2i18n("Max response (arcsec)", nullptr));
#if QT_CONFIG(tooltip)
        kcfg_RAIntegralGain->setToolTip(tr2i18n("<html><head/><body><p>This adds a correction term based on the average of the past 50 guide deviations. For example, if the deviation is consistently negative, this will attempt to compensate. Best to start with 0.0 (no effect) and only use this if necessary. (Only applies to the standard algorithm.)</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        l_15->setToolTip(tr2i18n("<html><head/><body><p>Minimum guide deviation, in arc-seconds, for which a guide pulse would be sent to the mount. If the guide error is less than this value, then no pulse is sent to the mount.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        l_15->setText(tr2i18n("Min error (arcsec)", nullptr));
#if QT_CONFIG(tooltip)
        kcfg_DECIntegralGain->setToolTip(tr2i18n("<html><head/><body><p>This adds a correction term based on the average of the past 50 guide deviations. For example, if the deviation is consistently negative, this will attempt to compensate. Best to start with 0.0 (no effect) and only use this if necessary. (Only applies to the standard algorithm.)</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        HysteresisGuiderLabel->setText(tr2i18n("Hysteresis", nullptr));
#if QT_CONFIG(tooltip)
        HysteresisGuiderLabel->setToolTip(tr2i18n("<html><head/><body><p>Sets the hysteresis parameter (only applies to the hysteresis algorithm).</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        kcfg_RAHysteresis->setToolTip(tr2i18n("<html><head/><body><p>Sets the RA hysteresis parameter (only applies to the hysteresis algorithm).</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        kcfg_DECHysteresis->setToolTip(tr2i18n("<html><head/><body><p>Sets the DEC hysteresis parameter (only applies to the hysteresis algorithm).</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        groupBox->setTitle(tr2i18n("Other Settings", nullptr));
        label_17->setText(tr2i18n("seconds", nullptr));
#if QT_CONFIG(tooltip)
        label_11->setToolTip(tr2i18n("<html><head/><body><p>If star tracking is lost due to passing clouds or other reasons, wait this many seconds before giving up.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        label_11->setText(tr2i18n("Lost Star timeout", nullptr));
#if QT_CONFIG(tooltip)
        label_13->setToolTip(tr2i18n("Maximum delta RMS permitted before stopping guide process and searching for new guide stars.", nullptr));
#endif // QT_CONFIG(tooltip)
        label_13->setText(tr2i18n("Max Delta RMS", nullptr));
#if QT_CONFIG(tooltip)
        label_24->setToolTip(tr2i18n("Maximum number of reference stars used by SEP MultiStar.", nullptr));
#endif // QT_CONFIG(tooltip)
        label_24->setText(tr2i18n("Max MultiStar Ref Stars", nullptr));
#if QT_CONFIG(tooltip)
        l_20->setToolTip(tr2i18n("The StellarSolver profile to use when detecting stars--used with the SEP MultiStar and SEP algorithms.", nullptr));
#endif // QT_CONFIG(tooltip)
        l_20->setText(tr2i18n("SEP Profile", nullptr));
#if QT_CONFIG(tooltip)
        kcfg_GuideMaxHFR->setToolTip(tr2i18n("Maximum HFR allowed for SEP MultiStar guide star.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        label_20->setToolTip(tr2i18n("Maximum HFR allowed for SEP MultiStar guide star.", nullptr));
#endif // QT_CONFIG(tooltip)
        label_20->setText(tr2i18n("Max MultiStar HFR", nullptr));
        label_12->setText(tr2i18n("seconds", nullptr));
        label_14->setText(tr2i18n("arcsecs", nullptr));
#if QT_CONFIG(tooltip)
        kcfg_AlwaysInventGuideStar->setToolTip(tr2i18n("<html><head/><body><p>If checked we try to be more resilient to double stars by inventing a guide star position from the multi-star references.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        kcfg_AlwaysInventGuideStar->setText(tr2i18n("Invent Multi-Star Guide Star", nullptr));
#if QT_CONFIG(tooltip)
        kcfg_SaveGuideLog->setToolTip(tr2i18n("<html><head/><body><p>If checked and the internal guider is run, a log file is saved in the default logging directory. This is not a debug log, it is meant for user's to improve logging and can be viewed with phd2logview.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        kcfg_SaveGuideLog->setText(tr2i18n("Save Internal Guider User Log", nullptr));
        label_23->setText(tr2i18n("stars", nullptr));
        kcfg_GuideAlgorithm->setItemText(0, tr2i18n("Smart", nullptr));
        kcfg_GuideAlgorithm->setItemText(1, tr2i18n("SEP", nullptr));
        kcfg_GuideAlgorithm->setItemText(2, tr2i18n("Fast", nullptr));
        kcfg_GuideAlgorithm->setItemText(3, tr2i18n("Auto Threshold", nullptr));
        kcfg_GuideAlgorithm->setItemText(4, tr2i18n("No Threshold", nullptr));
        kcfg_GuideAlgorithm->setItemText(5, tr2i18n("SEP Multi Star (recommended)", nullptr));

#if QT_CONFIG(tooltip)
        l_19->setToolTip(tr2i18n("The algorithm that tracks guide stars and determines the guide deviation.", nullptr));
#endif // QT_CONFIG(tooltip)
        l_19->setText(tr2i18n("Star Detection Algorithm", nullptr));
        label_21->setText(tr2i18n("pixels", nullptr));
        editGuideProfile->setText(QString());
#if QT_CONFIG(tooltip)
        kcfg_MinDetectionsSEPMultistar->setToolTip(tr2i18n("Minimum number of stars detected for SEP MultiStar to initialize.", nullptr));
#endif // QT_CONFIG(tooltip)
        label_25->setText(tr2i18n("stars", nullptr));
#if QT_CONFIG(tooltip)
        kcfg_MaxMultistarReferenceStars->setToolTip(tr2i18n("Maximum number of reference stars used by SEP MultiStar.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        label_22->setToolTip(tr2i18n("Minimum number of stars detected for SEP MultiStar to initialize.", nullptr));
#endif // QT_CONFIG(tooltip)
        label_22->setText(tr2i18n("Min MultiStar Star Detections", nullptr));
#if QT_CONFIG(tooltip)
        label_16->setToolTip(tr2i18n("<html><head/><body><p>[PHD2] If calibration takes more time than this many seconds, abort guiding.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        label_16->setText(tr2i18n("Calibration timeout", nullptr));
#if QT_CONFIG(tooltip)
        kcfg_UseGuideHead->setToolTip(tr2i18n("<html><head/><body><p>If the camera used for guiding has a dedicated guiding chip, you can decide which of the camera chips should be used for guiding: the primary chip or the guiding chip.</p><p>For cameras that have only one chip, this option is ignored.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        kcfg_UseGuideHead->setText(tr2i18n("Use dedicated Guiding Chip for Guiding", nullptr));
        (void)OpsGuide;
    } // retranslateUi

};

namespace Ui {
    class OpsGuide: public Ui_OpsGuide {};
} // namespace Ui

QT_END_NAMESPACE

#endif // OPSGUIDE_H

