SwitchTypeSetting(DiSEqCDevSwitch &switch_dev) :
        ComboBoxSetting(this), m_switch(switch_dev)
    {
        setLabel(DeviceTree::tr("Switch Type"));
        setHelpText(DeviceTree::tr("Select the type of switch from the list."));

        addSelection(DeviceTree::tr("Tone"),
                     QString::number((uint) DiSEqCDevSwitch::kTypeTone));
        addSelection(DeviceTree::tr("Voltage"),
                     QString::number((uint) DiSEqCDevSwitch::kTypeVoltage));
        addSelection(DeviceTree::tr("Mini DiSEqC"),
                     QString::number((uint) DiSEqCDevSwitch::kTypeMiniDiSEqC));
        addSelection(DeviceTree::tr("DiSEqC"),
                     QString::number((uint)
                                     DiSEqCDevSwitch::kTypeDiSEqCCommitted));
        addSelection(DeviceTree::tr("DiSEqC (Uncommitted)"),
                     QString::number((uint)
                                     DiSEqCDevSwitch::kTypeDiSEqCUncommitted));
        addSelection(DeviceTree::tr("Legacy SW21"),
                     QString::number((uint) DiSEqCDevSwitch::kTypeLegacySW21));
        addSelection(DeviceTree::tr("Legacy SW42"),
                     QString::number((uint) DiSEqCDevSwitch::kTypeLegacySW42));
        addSelection(DeviceTree::tr("Legacy SW64"),
                     QString::number((uint) DiSEqCDevSwitch::kTypeLegacySW64));
    }

FlightGearDataSource::FlightGearDataSource() : DataSource() {
    connect(&tcpClient, &BasicTcpClient::connectedChanged,
            this, &FlightGearDataSource::connectedChanged);
    connect(&tcpClient, &BasicTcpClient::receivedLine,
            this, &FlightGearDataSource::readLine);
    connect(&tcpClient, &BasicTcpClient::networkErrorChanged,
            this, &FlightGearDataSource::networkErrorChanged);

    // Fill the mappings of X-Plane <-> FlightGear data refs.
    refMap.insert("sim/cockpit2/gauges/indicators/heading_electric_deg_mag_pilot", "/instrumentation/magnetic-compass/indicated-heading-deg");
    refMap.insert("sim/cockpit2/gauges/indicators/airspeed_kts_pilot", "/instrumentation/airspeed-indicator/indicated-speed-kt");
    refMap.insert("sim/cockpit2/gauges/indicators/pitch_vacuum_deg_pilot", "/instrumentation/attitude-indicator/indicated-pitch-deg");
    refMap.insert("sim/cockpit2/gauges/indicators/roll_vacuum_deg_pilot", "/instrumentation/attitude-indicator/indicated-roll-deg");
    refMap.insert("sim/flightmodel/misc/h_ind", "/instrumentation/altimeter/indicated-altitude-ft");
    refMap.insert("sim/flightmodel/position/vh_ind", "/instrumentation/vertical-speed-indicator/indicated-speed-fpm");
    refMap.insert("sim/cockpit2/gauges/indicators/slip_deg", "/instrumentation/slip-skid-ball/indicated-slip-skid");
    // Please add more here


    // These are updated for every frame, so they should be polled at some
    // interval. Subscribing causes Error:Tied properties cannot register listeners
    // todo: implement polling mechanism
    // refMap.insert("sim/cockpit2/gauges/actuators/barometer_setting_in_hg_pilot", "/instrumentation/altimeter/setting-inhg");


    tcpClient.setLineEnding("\r\n");
    setHelpText("Start FlightGear with --telnet=5401 to allow access to it's properties. \nSee http://wiki.flightgear.org/Telnet_usage for more info. \nTrying to connect to it..");
}

void FlightGearDataSource::connectedChanged(bool connected)
{
    if(connected) {
        setNetworkError(QString());
        setHelpText(QString("Connected to FlightGear at %1:%2").arg(tcpClient.hostName()).arg(tcpClient.port()));
        tcpClient.writeLine("data");
    }
}

 ChannelCheckBox(const ChannelGroupConfig& _parent, const uint chanid, const QString channum,
            const QString channame, const QString grpname):
     CheckBoxSetting(this),
     ChannelGroupStorage(this, chanid, grpname)
 {
     setLabel(QString("%1 %2").arg(channum).arg(channame));
     setHelpText(QObject::tr("Select/Unselect channels for this channel group"));
 };

 explicit Extensions(const PlayerId &parent)
     : TextEdit(parent, "extensions")
 {
     setLabel(TR("File Extensions"));
     setHelpText(TR("A comma separated list of all file extensions for this "
                    "emulator. Blank means any file under ROM PATH is "
                    "considered to be used with this emulator"));
 }

 LNBLOFSwitchSetting(DiSEqCDevLNB &lnb) : LineEditSetting(this), m_lnb(lnb)
 {
     setLabel(DeviceTree::tr("LNB LOF Switch (MHz)"));
     QString help = DeviceTree::tr(
         "This defines at what frequency the LNB will do a "
         "switch from high to low setting, and vice versa.");
     setHelpText(help);
 }

 WorkingDirPath(const MythGamePlayerSettings &parent) :
     LineEditSetting(this), GameDBStorage(this, parent, "workingpath")
 {
     setLabel(MythGamePlayerSettings::tr("Working Directory"));
     setHelpText(MythGamePlayerSettings::tr("Directory to change to before "
                                            "launching emulator. Blank is "
                                            "usually fine"));
 };

 DeviceDescrSetting(DiSEqCDevDevice &device) :
     LineEditSetting(this), m_device(device)
 {
     setLabel(DeviceTree::tr("Description"));
     QString help = DeviceTree::tr(
         "Optional descriptive name for this device, to "
         "make it easier to configure settings later.");
     setHelpText(help);
 }

 LNBLOFHighSetting(DiSEqCDevLNB &lnb) : LineEditSetting(this), m_lnb(lnb)
 {
     setLabel(DeviceTree::tr("LNB LOF High (MHz)"));
     QString help = DeviceTree::tr(
         "This defines the offset the frequency coming from "
         "the LNB will be in high setting. For bandstacked "
         "LNBs this is the horizontal/left polarization band.");
     setHelpText(help);
 }

 LNBLOFLowSetting(DiSEqCDevLNB &lnb) : LineEditSetting(this), m_lnb(lnb)
 {
     setLabel(DeviceTree::tr("LNB LOF Low (MHz)"));
     QString help = DeviceTree::tr(
         "This defines the offset the frequency coming "
         "from the LNB will be in low setting. For bandstacked "
         "LNBs this is the vertical/right polarization band.");
     setHelpText(help);
 }

 RotorHiSpeedSetting(DiSEqCDevRotor &rotor) :
     LineEditSetting(this), m_rotor(rotor)
 {
     setLabel(DeviceTree::tr("Rotor High Speed (deg/sec)"));
     QString help = DeviceTree::tr(
         "To allow the approximate monitoring of rotor movement, enter "
         "the rated angular speed of the rotor when powered at 18V.");
     setHelpText(help);
 }

 DeviceRepeatSetting(DiSEqCDevDevice &device) :
     SpinBoxSetting(this, 0, 5, 1), m_device(device)
 {
     setLabel(DeviceTree::tr("Repeat Count"));
     QString help = DeviceTree::tr(
         "Number of times to repeat DiSEqC commands sent to this device. "
         "Larger values may help with less reliable devices.");
     setHelpText(help);
 }

 Freqid(const ChannelID &id) :
     LineEditSetting(this), ChannelDBStorage(this, id, "freqid")
 {
     setLabel(QCoreApplication::translate("(ChannelSettings)",
                                          "Frequency or Channel"));
     setHelpText(QCoreApplication::translate("(ChannelSettings)",
         "Specify either the exact frequency (in kHz) or a valid channel "
         "for your 'TV Format'."));
 }

    Icon(const ChannelID &id) :
        LineEditSetting(this), ChannelDBStorage(this, id, "icon")
    {
        setLabel(QCoreApplication::translate("(ChannelSettings)", "Icon"));

        setHelpText(QCoreApplication::translate("(ChannelSettings)",
            "Image file to use as the icon for this channel on various MythTV "
            "displays."));
    }

void CondorDatasource::connectToSource() {
    setNetworkError(QString());

    connect(&m_udpSocket, &QUdpSocket::readyRead, this, &CondorDatasource::readPendingDatagrams);
    if(m_udpSocket.bind(QHostAddress::LocalHost, m_port)) {
        setHelpText(QString("Listening to UDP transmissions on port %1. Please run Condor.\nSee config help at http://www.condorsoaring.com/manual/#simkits-and-udp-outputs").arg(m_port));
    } else {
        setNetworkError(QString("Unable to bind to UDP port %1!").arg(m_port));
    }
}

 RotorTypeSetting(DiSEqCDevRotor &rotor) :
     ComboBoxSetting(this), m_rotor(rotor)
 {
     setLabel(DeviceTree::tr("Rotor Type"));
     setHelpText(DeviceTree::tr("Select the type of rotor from the list."));
     addSelection(DeviceTree::tr("DiSEqC 1.2"),
                  QString::number((uint) DiSEqCDevRotor::kTypeDiSEqC_1_2));
     addSelection(DeviceTree::tr("DiSEqC 1.3 (GotoX/USALS)"),
                  QString::number((uint) DiSEqCDevRotor::kTypeDiSEqC_1_3));
 }

 AllowMultipleRoms(const MythGamePlayerSettings &parent) :
     CheckBoxSetting(this), GameDBStorage(this, parent, "spandisks")
 {
     setLabel(MythGamePlayerSettings::tr("Allow games to span multiple "
                                         "ROMs/disks"));
     setHelpText(MythGamePlayerSettings::tr("This setting means that we "
                                            "will look for items like "
                                            "game.1.rom, game.2.rom and "
                                            "consider them a single game."));
 };

    OnAirGuide(const ChannelID &id) :
        CheckBoxSetting(this), ChannelDBStorage(this, id, "useonairguide")
    {
        setLabel(QCoreApplication::translate("(ChannelSettings)",
                                             "Use on air guide"));

        setHelpText(QCoreApplication::translate("(ChannelSettings)", 
            "If enabled, guide information for this channel will be updated "
            "using 'Over-the-Air' program listings."));
    }

    Visible(const ChannelID &id) :
        CheckBoxSetting(this), ChannelDBStorage(this, id, "visible")
    {
        setValue(true);

        setLabel(QCoreApplication::translate("(ChannelSettings)", "Visible"));

        setHelpText(QCoreApplication::translate("(ChannelSettings)", 
            "If enabled, the channel will be visible in the EPG."));
    }

    OutputFilters(const ChannelID &id) :
        LineEditSetting(this), ChannelDBStorage(this, id, "outputfilters")
    {
        setLabel(QCoreApplication::translate("(ChannelSettings)",
                    "Playback filters"));

        setHelpText(QCoreApplication::translate("(ChannelSettings)",
            "Filters to be used when recordings from this channel are viewed. "
            "Start with a plus to append to the global playback filters."));
    }