anytone_codeplug.hh

#ifndef ANYTONECODEPLUG_HH
#define ANYTONECODEPLUG_HH
 
#include "codeplug.hh"
#include <QGeoCoordinate>
#include "channel.hh"
#include "contact.hh"
 
class RadioSettings;
 

class AnytoneCodeplug : public Codeplug
{
  Q_OBJECT
 
public:
  struct CTCSS {
  public:
    static uint8_t encode(const SelectiveCall &tone);
    static SelectiveCall decode(uint8_t code);
 
  protected:
    static SelectiveCall _codeTable[52];
  };

  class BitmapElement: public Element
  {
  protected:
    BitmapElement(uint8_t *ptr, size_t size);
 
  public:
    void clear();

    virtual bool isEncoded(unsigned int idx) const ;
    virtual void setEncoded(unsigned int idx, bool enable);
    virtual void enableFirst(unsigned int n);
  };

  class InvertedBitmapElement: public Element
  {
  protected:
    InvertedBitmapElement(uint8_t *ptr, size_t size);
 
  public:
    void clear();

    virtual bool isEncoded(unsigned int idx) const ;
    virtual void setEncoded(unsigned int idx, bool enable);
    virtual void enableFirst(unsigned int n);
  };

  class InvertedBytemapElement: public Element
  {
  protected:
    InvertedBytemapElement(uint8_t *ptr, size_t size);
 
  public:
    void clear();

    virtual bool isEncoded(unsigned int idx) const ;
    virtual void setEncoded(unsigned int idx, bool enable);
    virtual void enableFirst(unsigned int n);
  };

  class ChannelElement: public Element
  {
  public:
    enum class Mode {
      Analog      = 0,               
      Digital     = 1,               
      MixedAnalog = 2,               
      MixedDigital = 3               
    };

    enum Power {
      POWER_LOW    = 0,              
      POWER_MIDDLE = 1,              
      POWER_HIGH   = 2,              
      POWER_TURBO  = 3               
    };

    enum class RepeaterMode {
      Simplex  = 0,                  
      Positive = 1,                  
      Negative = 2                   
    };

    enum class SignalingMode {
      None = 0,                      
      CTCSS = 1,                     
      DCS = 2                        
    };

    enum class Admit {
      Always = 0,                  
      Free = 1,                    
      DifferentColorCode = 2,      
      SameColorCode = 3,               
      Tone = 1,                    
      Busy = 2                     
    };

    enum class OptSignaling {
      Off = 0,                    
      DTMF = 1,                   
      TwoTone = 2,                
      FiveTone = 3                
    };
 
  protected:
    ChannelElement(uint8_t *ptr, unsigned size);
 
  public:
    ChannelElement(uint8_t *ptr);
    virtual ~ChannelElement();

    static constexpr unsigned int size() { return 0x0040; }

    void clear();

    virtual unsigned rxFrequency() const;
    virtual void setRXFrequency(unsigned hz);

    virtual unsigned txOffset() const;
    virtual void setTXOffset(unsigned hz);
    virtual unsigned txFrequency() const;
    virtual void setTXFrequency(unsigned hz);

    virtual Mode mode() const;
    virtual void setMode(Mode mode);

    virtual Channel::Power power() const;
    virtual void setPower(Channel::Power power);

    virtual FMChannel::Bandwidth bandwidth() const;
    virtual void setBandwidth(FMChannel::Bandwidth bw);

    virtual RepeaterMode repeaterMode() const;
    virtual void setRepeaterMode(RepeaterMode mode);

    virtual SignalingMode rxSignalingMode() const;
    virtual void setRXSignalingMode(SignalingMode mode);
    virtual SelectiveCall rxTone() const;
    virtual void setRXTone(const SelectiveCall &code);

    virtual SignalingMode txSignalingMode() const;
    virtual void setTXSignalingMode(SignalingMode mode);
    virtual SelectiveCall txTone() const;
    virtual void setTXTone(const SelectiveCall &code);

    virtual bool ctcssPhaseReversal() const;
    virtual void enableCTCSSPhaseReversal(bool enable);

    virtual bool rxOnly() const;
    virtual void enableRXOnly(bool enable);
    virtual bool callConfirm() const;
    virtual void enableCallConfirm(bool enable);
    virtual bool talkaround() const;
    virtual void enableTalkaround(bool enable);

    virtual bool txCTCSSIsCustom() const;
    virtual SelectiveCall txCTCSS() const;
    virtual void setTXCTCSS(const SelectiveCall &tone);
    virtual void enableTXCustomCTCSS();
    virtual bool rxCTCSSIsCustom() const;
    virtual SelectiveCall rxCTCSS() const;
    virtual void setRXCTCSS(const SelectiveCall &tone);
    virtual void enableRXCustomCTCSS();

    virtual SelectiveCall txDCS() const;
    virtual void setTXDCS(const SelectiveCall &code);
    virtual SelectiveCall rxDCS() const;
    virtual void setRXDCS(const SelectiveCall &code);

    virtual double customCTCSSFrequency() const;
    virtual void setCustomCTCSSFrequency(double hz);

    virtual unsigned twoToneDecodeIndex() const;
    virtual void setTwoToneDecodeIndex(unsigned idx);

    virtual unsigned contactIndex() const;
    virtual void setContactIndex(unsigned idx);

    virtual unsigned radioIDIndex() const;
    virtual void setRadioIDIndex(unsigned idx);

    virtual AnytoneFMChannelExtension::SquelchMode squelchMode() const;
    virtual void setSquelchMode(AnytoneFMChannelExtension::SquelchMode mode);

    virtual Admit admit() const;
    virtual void setAdmit(Admit admit);

    virtual OptSignaling optionalSignaling() const;
    virtual void setOptionalSignaling(OptSignaling sig);

    virtual bool hasScanListIndex() const;
    virtual unsigned scanListIndex() const;
    virtual void setScanListIndex(unsigned idx);
    virtual void clearScanListIndex();

    virtual bool hasGroupListIndex() const;
    virtual unsigned groupListIndex() const;
    virtual void setGroupListIndex(unsigned idx);
    virtual void clearGroupListIndex();

    virtual unsigned twoToneIDIndex() const;
    virtual void setTwoToneIDIndex(unsigned idx);
    virtual unsigned fiveToneIDIndex() const;
    virtual void setFiveToneIDIndex(unsigned idx);
    virtual unsigned dtmfIDIndex() const;
    virtual void setDTMFIDIndex(unsigned idx);

    virtual unsigned colorCode() const;
    virtual void setColorCode(unsigned code);

    virtual DMRChannel::TimeSlot timeSlot() const;
    virtual void setTimeSlot(DMRChannel::TimeSlot ts);

    virtual bool smsConfirm() const;
    virtual void enableSMSConfirm(bool enable);
    virtual bool simplexTDMA() const;
    virtual void enableSimplexTDMA(bool enable);
    virtual bool adaptiveTDMA() const;
    virtual void enableAdaptiveTDMA(bool enable);
    virtual bool rxAPRS() const;
    virtual void enableRXAPRS(bool enable);
    virtual bool enhancedEncryption() const;
    virtual void enableEnhancedEncryption(bool enable);
    virtual bool loneWorker() const;
    virtual void enableLoneWorker(bool enable);

    virtual bool hasEncryptionKeyIndex() const;
    virtual unsigned encryptionKeyIndex() const;
    virtual void setEncryptionKeyIndex(unsigned idx);
    virtual void clearEncryptionKeyIndex();

    virtual QString name() const;
    virtual void setName(const QString &name);

    virtual Channel *toChannelObj(Context &ctx) const;
    virtual bool linkChannelObj(Channel *c, Context &ctx) const;
    virtual bool fromChannelObj(const Channel *c, Context &ctx);
 
  protected:
    struct Offset {
    };
  };

  class ChannelBitmapElement: public BitmapElement
  {
  protected:
    ChannelBitmapElement(uint8_t *ptr, size_t size);
 
  public:
    ChannelBitmapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0200; }
  };

  class ContactElement: public Element
  {
  protected:
    ContactElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit ContactElement(uint8_t *ptr);
    virtual ~ContactElement();

    static constexpr unsigned int size() { return 0x0064; }

    void clear();
    bool isValid() const;

    virtual DMRContact::Type type() const;
    virtual void setType(DMRContact::Type type);

    virtual QString name() const;
    virtual void setName(const QString &name);

    virtual unsigned number() const;
    virtual void setNumber(unsigned number);

    virtual AnytoneContactExtension::AlertType alertType() const;
    virtual void setAlertType(AnytoneContactExtension::AlertType type);

    virtual DMRContact *toContactObj(Context &ctx) const;
    virtual bool fromContactObj(const DMRContact *contact, Context &ctx);
  };

  class ContactBitmapElement: public InvertedBitmapElement
  {
  protected:
    ContactBitmapElement(uint8_t *ptr, size_t size);
 
  public:
    ContactBitmapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0500; }
  };

  class DTMFContactElement: public Element
  {
  protected:
    DTMFContactElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit DTMFContactElement(uint8_t *ptr);
    virtual ~DTMFContactElement();

    static constexpr unsigned int size() { return 0x0018; }

    void clear();

    virtual QString number() const;
    virtual void setNumber(const QString &number);

    virtual QString name() const;
    virtual void setName(const QString &name);

    virtual DTMFContact *toContact() const;
    virtual bool fromContact(const DTMFContact *contact);
 
  public:
    struct Limit {
      static constexpr unsigned int digitCount() { return 14; }       
      static constexpr unsigned int nameLength() { return 15; }       
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int digits()    { return 0x0000; }
      static constexpr unsigned int numDigits() { return 0x0007; }
      static constexpr unsigned int name()      { return 0x0008; }
    };
  };

  class DTMFContactBytemapElement: public InvertedBytemapElement
  {
  protected:
    DTMFContactBytemapElement(uint8_t *ptr, size_t size);
 
  public:
    explicit DTMFContactBytemapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0100; }
  };

  class GroupListElement: public Element
  {
  protected:
    GroupListElement(uint8_t *ptr, unsigned size);
 
  public:
    GroupListElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0120; }

    void clear();
    bool isValid() const;

    virtual QString name() const;
    virtual void setName(const QString &name);

    virtual bool hasMemberIndex(unsigned n) const;
    virtual unsigned memberIndex(unsigned n) const;
    virtual void setMemberIndex(unsigned n, unsigned idx);
    virtual void clearMemberIndex(unsigned n);

    virtual RXGroupList *toGroupListObj() const;
    virtual bool linkGroupList(RXGroupList *lst, Context &ctx) const;
    virtual bool fromGroupListObj(const RXGroupList *lst, Context &ctx);
  };

  class GroupListBitmapElement: public BitmapElement
  {
  protected:
    GroupListBitmapElement(uint8_t *ptr, size_t size);
 
  public:
    explicit GroupListBitmapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0020; }
  };

  class ScanListElement: public Element
  {
  public:
    enum class PriChannel {
      Off = 0,                   
      Primary = 1,               
      Secondary = 2,             
      Both = 3                   
    };

    enum class RevertChannel {
      Selected = 0,              
      SelectedActive = 1,        
      Primary = 2,               
      Secondary = 3,             
      LastCalled = 4,            
      LastUsed = 5,              
      PrimaryActive = 6,         
      SecondaryActive = 7        
    };
 
  protected:
    ScanListElement(uint8_t *ptr, unsigned size);
 
  public:
    ScanListElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0090; }

    void clear();

    virtual PriChannel priorityChannels() const;
    virtual void setPriorityChannels(PriChannel sel);

    virtual bool hasPrimary() const;
    virtual bool primaryIsSelected() const;
    virtual unsigned primary() const;
    virtual void setPrimary(unsigned idx);
    virtual void setPrimarySelected();
    virtual void clearPrimaryChannel();

    virtual bool hasSecondary() const;
    virtual bool secondaryIsSelected() const;
    virtual unsigned secondary() const;
    virtual void setSecondary(unsigned idx);
    virtual void setSecondarySelected();
    virtual void clearSecondaryChannel();

    virtual unsigned lookBackTimeA() const;
    virtual void setLookBackTimeA(unsigned sec);
    virtual unsigned lookBackTimeB() const;
    virtual void setLookBackTimeB(unsigned sec);
    virtual unsigned dropOutDelay() const;
    virtual void setDropOutDelay(unsigned sec);
    virtual unsigned dwellTime() const;
    virtual void setDwellTime(unsigned sec);

    virtual RevertChannel revertChannel() const;
    virtual void setRevertChannel(RevertChannel type);

    virtual QString name() const;
    virtual void setName(const QString &name);

    virtual bool hasMemberIndex(unsigned n) const;
    virtual unsigned memberIndex(unsigned n) const;
    virtual void setMemberIndex(unsigned n, unsigned idx);
    virtual void clearMemberIndex(unsigned n);

    virtual ScanList *toScanListObj() const;
    virtual bool linkScanListObj(ScanList *lst, Context &ctx) const;
    virtual bool fromScanListObj(ScanList *lst, Context &ctx);
  };

  class ScanListBitmapElement: public BitmapElement
  {
  protected:
    ScanListBitmapElement(uint8_t *ptr, size_t size);
 
  public:
    ScanListBitmapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x00000020; }
  };

  class RadioIDElement: public Element
  {
  protected:
    RadioIDElement(uint8_t *ptr, unsigned size);
 
  public:
    RadioIDElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0020; }

    void clear();

    virtual unsigned number() const;
    virtual void setNumber(unsigned number);

    virtual QString name() const;
    virtual void setName(const QString &name);

    virtual bool fromRadioID(DMRRadioID *id);
    virtual DMRRadioID *toRadioID() const;
  };

  class RadioIDBitmapElement: public BitmapElement
  {
  protected:
    RadioIDBitmapElement(uint8_t *ptr, size_t size);
 
  public:
    RadioIDBitmapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0020; }
  };

  class GeneralSettingsElement: public Element
  {
  public:
    enum class AutoShutdown {
      Off = 0, After10min = 1, After30min  = 2, After60min  = 3, After120min = 4,
    };
 
  protected:
    GeneralSettingsElement(uint8_t *ptr, unsigned size);
 
  public:
    void clear();

    virtual bool keyToneEnabled() const = 0;
    virtual void enableKeyTone(bool enable) = 0;

    virtual bool displayFrequency() const;
    virtual void enableDisplayFrequency(bool enable);
    virtual bool autoKeyLock() const;
    virtual void enableAutoKeyLock(bool enable);
    virtual Interval autoShutdownDelay() const;
    virtual void setAutoShutdownDelay(Interval min);
    virtual AnytoneBootSettingsExtension::BootDisplay bootDisplay() const;
    virtual void setBootDisplay(AnytoneBootSettingsExtension::BootDisplay mode);
    virtual bool bootPassword() const;
    virtual void enableBootPassword(bool enable);
    virtual unsigned squelchLevelA() const;
    virtual void setSquelchLevelA(unsigned level);
    virtual unsigned squelchLevelB() const;
    virtual void setSquelchLevelB(unsigned level);

    virtual AnytoneSettingsExtension::VFOScanType vfoScanType() const = 0;
    virtual void setVFOScanType(AnytoneSettingsExtension::VFOScanType type) = 0;
    virtual unsigned dmrMicGain() const = 0;
    virtual void setDMRMicGain(unsigned int gain) = 0;

    virtual AnytoneKeySettingsExtension::KeyFunction funcKeyAShort() const = 0;
    virtual void setFuncKeyAShort(AnytoneKeySettingsExtension::KeyFunction func) = 0;
    virtual AnytoneKeySettingsExtension::KeyFunction funcKeyBShort() const = 0;
    virtual void setFuncKeyBShort(AnytoneKeySettingsExtension::KeyFunction func) = 0;
    virtual AnytoneKeySettingsExtension::KeyFunction funcKeyCShort() const = 0;
    virtual void setFuncKeyCShort(AnytoneKeySettingsExtension::KeyFunction func) = 0;
    virtual AnytoneKeySettingsExtension::KeyFunction funcKey1Short() const = 0;
    virtual void setFuncKey1Short(AnytoneKeySettingsExtension::KeyFunction func) = 0;
    virtual AnytoneKeySettingsExtension::KeyFunction funcKey2Short() const = 0;
    virtual void setFuncKey2Short(AnytoneKeySettingsExtension::KeyFunction func) = 0;

    virtual AnytoneKeySettingsExtension::KeyFunction funcKeyALong() const = 0;
    virtual void setFuncKeyALong(AnytoneKeySettingsExtension::KeyFunction func) = 0;
    virtual AnytoneKeySettingsExtension::KeyFunction funcKeyBLong() const = 0;
    virtual void setFuncKeyBLong(AnytoneKeySettingsExtension::KeyFunction func) = 0;
    virtual AnytoneKeySettingsExtension::KeyFunction funcKeyCLong() const = 0;
    virtual void setFuncKeyCLong(AnytoneKeySettingsExtension::KeyFunction func) = 0;
    virtual AnytoneKeySettingsExtension::KeyFunction funcKey1Long() const = 0;
    virtual void setFuncKey1Long(AnytoneKeySettingsExtension::KeyFunction func) = 0;
    virtual AnytoneKeySettingsExtension::KeyFunction funcKey2Long() const = 0;
    virtual void setFuncKey2Long(AnytoneKeySettingsExtension::KeyFunction func) = 0;

    virtual Interval longPressDuration() const = 0;
    virtual void setLongPressDuration(Interval ms) = 0;

    virtual bool knobLock() const = 0;
    virtual void enableKnobLock(bool enable) = 0;
    virtual bool keypadLock() const = 0;
    virtual void enableKeypadLock(bool enable) = 0;
    virtual bool sidekeysLock() const = 0;
    virtual void enableSidekeysLock(bool enable) = 0;
    virtual bool keyLockForced() const = 0;
    virtual void enableKeyLockForced(bool enable) = 0;
 
  public:
    virtual bool vfoModeA() const = 0;
    virtual void enableVFOModeA(bool enable) = 0;
    virtual bool vfoModeB() const = 0;
    virtual void enableVFOModeB(bool enable) = 0;

    virtual unsigned memoryZoneA() const = 0;
    virtual void setMemoryZoneA(unsigned zone) = 0;
    virtual unsigned memoryZoneB() const = 0;
    virtual void setMemoryZoneB(unsigned zone) = 0;

    virtual bool recording() const = 0;
    virtual void enableRecording(bool enable) = 0;

    virtual unsigned brightness() const = 0;
    virtual void setBrightness(unsigned level) = 0;

    virtual bool gps() const = 0;
    virtual void enableGPS(bool enable) = 0;
    virtual bool smsAlert() const = 0;
    virtual void enableSMSAlert(bool enable) = 0;
    virtual bool activeChannelB() const = 0;
    virtual void enableActiveChannelB(bool enable) = 0;
    virtual bool subChannel() const = 0;
    virtual void enableSubChannel(bool enable) = 0;
    virtual bool callAlert() const = 0;
    virtual void enableCallAlert(bool enable) = 0;

    virtual QTimeZone gpsTimeZone() const = 0;
    virtual void setGPSTimeZone(const QTimeZone &zone) = 0;
    virtual bool dmrTalkPermit() const = 0;
    virtual bool fmTalkPermit() const = 0;
    virtual void enableDMRTalkPermit(bool enable) = 0;
    virtual void enableFMTalkPermit(bool enable) = 0;
    virtual bool dmrResetTone() const = 0;
    virtual void enableDMRResetTone(bool enable) = 0;

    virtual bool idleChannelTone() const = 0;
    virtual void enableIdleChannelTone(bool enable) = 0;
    virtual Interval menuExitTime() const = 0;
    virtual void setMenuExitTime(Interval intv) = 0;
    virtual bool startupTone() const = 0;
    virtual void enableStartupTone(bool enable) = 0;
    virtual bool callEndPrompt() const = 0;
    virtual void enableCallEndPrompt(bool enable) = 0;
    virtual unsigned maxSpeakerVolume() const = 0;
    virtual void setMaxSpeakerVolume(unsigned level) = 0;
    virtual bool getGPSPosition() const = 0;
    virtual void enableGetGPSPosition(bool enable) = 0;

    virtual bool volumeChangePrompt() const = 0;
    virtual void enableVolumeChangePrompt(bool enable) = 0;
    virtual AnytoneAutoRepeaterSettingsExtension::Direction autoRepeaterDirectionA() const = 0;
    virtual void setAutoRepeaterDirectionA(AnytoneAutoRepeaterSettingsExtension::Direction dir) = 0;
    virtual AnytoneDisplaySettingsExtension::LastCallerDisplayMode lastCallerDisplayMode() const = 0;
    virtual void setLastCallerDisplayMode(AnytoneDisplaySettingsExtension::LastCallerDisplayMode mode) = 0;

    virtual bool displayClock() const = 0;
    virtual void enableDisplayClock(bool enable) = 0;
    virtual bool enhanceAudio() const = 0;
    virtual void enableEnhancedAudio(bool enable) = 0;
    virtual Frequency minVFOScanFrequencyUHF() const = 0;
    virtual void setMinVFOScanFrequencyUHF(Frequency hz) = 0;
    virtual Frequency maxVFOScanFrequencyUHF() const = 0;
    virtual void setMaxVFOScanFrequencyUHF(Frequency hz) = 0;

    virtual Frequency minVFOScanFrequencyVHF() const = 0;
    virtual void setMinVFOScanFrequencyVHF(Frequency hz) = 0;
    virtual Frequency maxVFOScanFrequencyVHF() const = 0;
    virtual void setMaxVFOScanFrequencyVHF(Frequency hz) = 0;

    virtual bool hasAutoRepeaterOffsetFrequencyIndexUHF() const = 0;
    virtual unsigned autoRepeaterOffsetFrequencyIndexUHF() const = 0;
    virtual void setAutoRepeaterOffsetFrequenyIndexUHF(unsigned idx) = 0;
    virtual void clearAutoRepeaterOffsetFrequencyIndexUHF() = 0;
    virtual bool hasAutoRepeaterOffsetFrequencyIndexVHF() const = 0;
    virtual unsigned autoRepeaterOffsetFrequencyIndexVHF() const = 0;
    virtual void setAutoRepeaterOffsetFrequenyIndexVHF(unsigned idx) = 0;
    virtual void clearAutoRepeaterOffsetFrequencyIndexVHF() = 0;

    virtual bool showCurrentContact() const = 0;
    virtual void enableShowCurrentContact(bool enable) = 0;

    virtual void callToneMelody(Melody &melody) const = 0;
    virtual void setCallToneMelody(const Melody &melody) = 0;
    virtual void idleToneMelody(Melody &melody) const = 0;
    virtual void setIdleToneMelody(const Melody &melody) = 0;
    virtual void resetToneMelody(Melody &melody) const = 0;
    virtual void setResetToneMelody(const Melody &melody) = 0;

    virtual bool defaultChannel() const = 0;
    virtual void enableDefaultChannel(bool enable) = 0;
    virtual unsigned defaultZoneIndexA() const = 0;
    virtual void setDefaultZoneIndexA(unsigned idx) = 0;
    virtual unsigned defaultZoneIndexB() const = 0;
    virtual void setDefaultZoneIndexB(unsigned idx) = 0;
    virtual bool defaultChannelAIsVFO() const = 0;
    virtual unsigned defaultChannelAIndex() const = 0;
    virtual void setDefaultChannelAIndex(unsigned idx) = 0;
    virtual void setDefaultChannelAToVFO() = 0;
    virtual bool defaultChannelBIsVFO() const = 0;
    virtual unsigned defaultChannelBIndex() const = 0;
    virtual void setDefaultChannelBIndex(unsigned idx) = 0;
    virtual void setDefaultChannelBToVFO() = 0;

    virtual bool displayCall() const = 0;
    virtual void enableDisplayCall(bool enable) = 0;

    virtual AnytoneDisplaySettingsExtension::Color callDisplayColor() const = 0;
    virtual void setCallDisplayColor(AnytoneDisplaySettingsExtension::Color color) = 0;

    virtual bool gpsUnitsImperial() const = 0;
    virtual void enableGPSUnitsImperial(bool enable) = 0;

    virtual Frequency autoRepeaterMinFrequencyVHF() const = 0;
    virtual void setAutoRepeaterMinFrequencyVHF(Frequency Hz) = 0;
    virtual Frequency autoRepeaterMaxFrequencyVHF() const = 0;
    virtual void setAutoRepeaterMaxFrequencyVHF(Frequency Hz) = 0;

    virtual Frequency autoRepeaterMinFrequencyUHF() const = 0;
    virtual void setAutoRepeaterMinFrequencyUHF(Frequency Hz) = 0;
    virtual Frequency autoRepeaterMaxFrequencyUHF() const = 0;
    virtual void setAutoRepeaterMaxFrequencyUHF(Frequency Hz) = 0;
    virtual AnytoneAutoRepeaterSettingsExtension::Direction autoRepeaterDirectionB() const = 0;
    virtual void setAutoRepeaterDirectionB(AnytoneAutoRepeaterSettingsExtension::Direction dir) = 0;

    virtual bool showLastHeard() const = 0;
    virtual void enableShowLastHeard(bool enable) = 0;

    virtual bool keepLastCaller() const = 0;
    virtual void enableKeepLastCaller(bool enable) = 0;

    virtual bool fromConfig(const Flags &flags, Context &ctx);
    virtual bool updateConfig(Context &ctx);
    virtual bool linkSettings(RadioSettings *settings, Context &ctx, const ErrorStack &err=ErrorStack());
 
  protected:
    struct Offset : public Element::Offset {
      static constexpr unsigned int displayMode()     { return 0x0001; }
      static constexpr unsigned int autoKeyLock()     { return 0x0002; }
      static constexpr unsigned int autoShutDown()    { return 0x0003; }
      static constexpr unsigned int bootDisplay()     { return 0x0006; }
      static constexpr unsigned int bootPassword()    { return 0x0007; }
      static constexpr unsigned int squelchLevelA()   { return 0x0009; }
      static constexpr unsigned int squelchLevelB()   { return 0x000a; }
    };
  };

  class ExtendedSettingsElement: public Element
  {
  protected:
    ExtendedSettingsElement(uint8_t *ptr, unsigned size);
 
  public:
    virtual bool sendTalkerAlias() const = 0;
    virtual void enableSendTalkerAlias(bool enable) = 0;

    virtual AnytoneDMRSettingsExtension::TalkerAliasSource talkerAliasSource() const = 0;
    virtual void setTalkerAliasSource(AnytoneDMRSettingsExtension::TalkerAliasSource mode) = 0;

    virtual AnytoneDMRSettingsExtension::TalkerAliasEncoding talkerAliasEncoding() const = 0;
    virtual void setTalkerAliasEncoding(AnytoneDMRSettingsExtension::TalkerAliasEncoding encoding) = 0;

    virtual AnytoneDisplaySettingsExtension::Color channelBNameColor() const = 0;
    virtual void setChannelBNameColor(AnytoneDisplaySettingsExtension::Color) = 0;

    virtual AnytoneDisplaySettingsExtension::Color zoneANameColor() const = 0;
    virtual void setZoneANameColor(AnytoneDisplaySettingsExtension::Color) = 0;

    virtual AnytoneDisplaySettingsExtension::Color zoneBNameColor() const = 0;
    virtual void setZoneBNameColor(AnytoneDisplaySettingsExtension::Color) = 0;

    virtual bool fromConfig(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack());
    virtual bool updateConfig(Context &ctx, const ErrorStack &err=ErrorStack());
    virtual bool linkConfig(Context &ctx, const ErrorStack &err=ErrorStack());
  };

  class ZoneChannelListElement: public Element
  {
  protected:
    ZoneChannelListElement(uint8_t *ptr, unsigned size);
 
  public:
    ZoneChannelListElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0400; }

    void clear();

    virtual bool hasChannelA(unsigned n) const;
    virtual unsigned channelIndexA(unsigned n) const;
    virtual void setChannelIndexA(unsigned n, unsigned idx);
    virtual void clearChannelIndexA(unsigned n);

    virtual bool hasChannelB(unsigned n) const;
    virtual unsigned channelIndexB(unsigned n) const;
    virtual void setChannelIndexB(unsigned n, unsigned idx);
    virtual void clearChannelIndexB(unsigned n);
  };

  class ZoneBitmapElement: public BitmapElement
  {
  protected:
    ZoneBitmapElement(uint8_t *ptr, size_t size);
 
  public:
    ZoneBitmapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0020; }
  };

  class BootSettingsElement: public Element
  {
  protected:
    BootSettingsElement(uint8_t *ptr, unsigned size);
 
  public:
    BootSettingsElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0030; }

    void clear();

    virtual QString introLine1() const;
    virtual void setIntroLine1(const QString &txt);
    virtual QString introLine2() const;
    virtual void setIntroLine2(const QString &txt);

    virtual QString password() const;
    virtual void setPassword(const QString &txt);

    virtual bool fromConfig(const Flags &flags, Context &ctx);
    virtual bool updateConfig(Context &ctx);
  };

  class DMRAPRSSettingsElement: public Element
  {
  protected:
    DMRAPRSSettingsElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit DMRAPRSSettingsElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0030; }

    void clear();

    virtual unsigned manualInterval() const;
    virtual void setManualInterval(unsigned sec);

    virtual bool automatic() const;
    virtual unsigned automaticInterval() const;
    virtual void setAutomaticInterval(unsigned sec);
    virtual void disableAutomatic();

    virtual bool fixedLocation() const;
    virtual QGeoCoordinate location() const;
    virtual void setLocation(const QGeoCoordinate &pos);
    virtual void enableFixedLocation(bool enable);

    virtual Channel::Power power() const;
    virtual void setPower(Channel::Power power);

    virtual bool hasChannel(unsigned n) const;
    virtual bool channelIsVFOA(unsigned n) const;
    virtual bool channelIsVFOB(unsigned n) const;
    virtual bool channelIsSelected(unsigned n) const;
    virtual unsigned channelIndex(unsigned n) const;
    virtual void setChannelIndex(unsigned n, unsigned idx);
    virtual void setChannelVFOA(unsigned n);
    virtual void setChannelVFOB(unsigned n);
    virtual void setChannelSelected(unsigned n);
    virtual void clearChannel(unsigned n);

    virtual unsigned destination() const;
    virtual void setDestination(unsigned id);

    virtual DMRContact::Type callType() const;
    virtual void setCallType(DMRContact::Type type);

    virtual bool timeSlotOverride() const;
    virtual DMRChannel::TimeSlot timeslot() const;
    virtual void overrideTimeSlot(DMRChannel::TimeSlot ts);
    virtual void disableTimeSlotOverride();

    virtual bool fromConfig(const Flags &flags, Context &ctx);
    virtual bool createGPSSystem(uint8_t i, Context &ctx);
    virtual bool linkGPSSystem(uint8_t i, Context &ctx);
  };

  class DMRAPRSMessageElement: public Element
  {
  protected:
    DMRAPRSMessageElement(uint8_t *ptr, size_t size);
 
  public:
    DMRAPRSMessageElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0030; }
 
    void clear();

    virtual QString message() const;
    void setMessage(const QString &message);

    virtual bool fromConfig(Codeplug::Flags flags, Context &ctx);
    virtual bool updateConfig(Context &ctx) const;
 
  public:
    struct Limit {
      static constexpr unsigned int length() { return 32; }      
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int message() { return 0x0000; }
    };
  };

  class RepeaterOffsetListElement: public Element
  {
  protected:
    RepeaterOffsetListElement(uint8_t *ptr, size_t size);
 
  public:
    explicit RepeaterOffsetListElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x03f0; }
 
    void clear();

    virtual bool isSet(unsigned int n) const;
    virtual Frequency offset(unsigned int n) const;
    virtual void setOffset(unsigned int n, Frequency freq);
    virtual void clearOffset(unsigned int n);
 
  public:
    struct Limit {
      static constexpr unsigned int numEntries() { return 250; }      
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int frequencies() { return 0x0000; }
      static constexpr unsigned int betweenFrequencies() { return sizeof(uint32_t); }
    };
  };

  class MessageListElement: public Element
  {
  protected:
    MessageListElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit MessageListElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0010; }

    void clear();

    virtual bool hasNext() const;
    virtual unsigned next() const;
    virtual void setNext(unsigned idx);
    virtual void clearNext();

    virtual bool hasIndex() const;
    virtual unsigned index() const;
    virtual void setIndex(unsigned idx);
    virtual void clearIndex();
  };

  class MessageElement: public Element
  {
  protected:
    MessageElement(uint8_t *ptr, unsigned size);
 
  public:
    MessageElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0100; }

    void clear();

    virtual QString message() const;
    virtual void setMessage(const QString &msg);
  };

  class MessageBytemapElement: public InvertedBytemapElement
  {
  protected:
    MessageBytemapElement(uint8_t *ptr, size_t size);
 
  public:
    MessageBytemapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0090; }
  };

  class AnalogQuickCallElement: public Element
  {
  public:
    enum class Type {
      None     = 0,                
      DTMF     = 1,                
      TwoTone  = 2,                
      FiveTone = 3                 
    };
 
  protected:
    AnalogQuickCallElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit AnalogQuickCallElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0002; }

    void clear();

    virtual Type type() const;
    virtual void setType(Type type);

    virtual bool hasContactIndex() const;
    virtual unsigned contactIndex() const;
    virtual void setContactIndex(unsigned idx);
    virtual void clearContactIndex();
  };

  class AnalogQuickCallsElement: public Element
  {
  protected:
    AnalogQuickCallsElement(uint8_t *ptr, size_t size);
 
  public:
    AnalogQuickCallsElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0100; }

    void clear();

    uint8_t *quickCall(unsigned int n) const;
 
  public:
    struct Limit {
      static constexpr unsigned int numEntries() { return 4; }   
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int quickCalls() { return 0x0000; }
    };
  };

  class StatusMessagesElement: public Element
  {
  protected:
    StatusMessagesElement(uint8_t *ptr, size_t size);
 
  public:
    StatusMessagesElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0400; }
 
    void clear();

    virtual QString message(unsigned int n) const;
    virtual void setMessage(unsigned int n, const QString &msg);
 
  public:
    struct Limit {
      static constexpr unsigned int numMessages()   { return 32; }    
      static constexpr unsigned int messageLength() { return 32; }    
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int messages()        { return 0x0000; }
      static constexpr unsigned int betweenMessages() { return 0x0020; }
    };
  };

  class StatusMessageBitmapElement: public BitmapElement
  {
  protected:
    StatusMessageBitmapElement(uint8_t *ptr, size_t size);
 
  public:
    StatusMessageBitmapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0010; }
  };

  class HotKeyElement: public Element
  {
  public:
    enum class Type {
      Call = 0,             
      Menu = 1              
    };

    enum class MenuItem {
      SMS = 1,          
      NewSMS = 2,       
      HotText = 3,      
      Inbox = 4,        
      Outbox = 5,       
      Contacts = 6,     
      ManualDial = 7,   
      CallLog = 8       
    };

    enum class CallType {
      Analog = 0,       
      Digital = 1       
    };

    enum class DigiCallType {
      Off = 0xff,          
      GroupCall = 0,       
      PrivateCall= 1,      
      AllCall = 2,         
      HotText = 3,         
      CallTip = 4,         
      StatusMessage = 5    
    };
 
  protected:
    HotKeyElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit HotKeyElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0030; }

    void clear();

    virtual Type type() const;
    virtual void setType(Type type);

    virtual MenuItem menuItem() const;
    virtual void setMenuItem(MenuItem item);

    virtual CallType callType() const;
    virtual void setCallType(CallType type);

    virtual DigiCallType digiCallType() const;
    virtual void setDigiCallType(DigiCallType type);

    virtual bool hasContactIndex() const;
    virtual unsigned contactIndex() const;
    virtual void setContactIndex(unsigned idx);
    virtual void clearContactIndex();

    virtual bool hasMessageIndex() const;
    virtual unsigned messageIndex() const;
    virtual void setMessageIndex(unsigned idx);
    virtual void clearMessageIndex();
  };

  class HotKeySettingsElement: public Element
  {
  protected:
    HotKeySettingsElement(uint8_t *ptr, size_t size);
 
  public:
    HotKeySettingsElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0360; }
 
    void clear();

    virtual uint8_t *hotKeySetting(unsigned int n) const;
 
  public:
    struct Limit {
      static constexpr unsigned int numEntries() { return 18; }   
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int hotKeySettings()        { return 0x0000; }
      static constexpr unsigned int betweenHotKeySettings() { return HotKeySettingsElement::size(); }
    };
  };

  class AlarmSettingElement: public Element
  {
  public:
    class AnalogAlarm: public Element
    {
    public:
      enum class Action {
        None = 0,            
        Background = 1,      
        TXAlarm = 2,         
        Both = 3,            
      };

      enum class ENIType {
        None = 0,            
        DTMF = 1,            
        FiveTone = 2         
      };
 
    protected:
      AnalogAlarm(uint8_t *ptr, unsigned size);
 
    public:
      AnalogAlarm(uint8_t *ptr);

      static constexpr unsigned int size() { return 0x000a; }

      void clear();

      virtual Action action() const;
      virtual void setAction(Action action);

      virtual ENIType encodingType() const;
      virtual void setEncodingType(ENIType type);

      virtual unsigned emergencyIndex() const;
      virtual void setEmergencyIndex(unsigned idx);

      virtual unsigned duration() const;
      virtual void setDuration(unsigned sec);
      virtual unsigned txDuration() const;
      virtual void setTXDuration(unsigned sec);
      virtual unsigned rxDuration() const;
      virtual void setRXDuration(unsigned sec);

      virtual bool channelIsSelected() const;
      virtual unsigned channelIndex() const;
      virtual void setChannelIndex(unsigned idx);
      virtual void setChannelSelected();

      virtual bool repeatContinuously() const;
      virtual unsigned repetitions() const;
      virtual void setRepetitions(unsigned num);
      virtual void setRepatContinuously();
    };

    class DigitalAlarm: public Element
    {
    public:
      enum class Action {
        None = 0,           
        Background = 1,     
        NonLocal = 2,       
        Local = 3,          
      };
 
    protected:
      DigitalAlarm(uint8_t *ptr, unsigned size);
 
    public:
      explicit DigitalAlarm(uint8_t *ptr);

      static constexpr unsigned int size() { return 0x000c; }

      void clear();

      virtual Action action() const;
      virtual void setAction(Action action);

      virtual unsigned duration() const;
      virtual void setDuration(unsigned sec);
      virtual unsigned txDuration() const;
      virtual void setTXDuration(unsigned sec);
      virtual unsigned rxDuration() const;
      virtual void setRXDuration(unsigned sec);

      virtual bool channelIsSelected() const;
      virtual unsigned channelIndex() const;
      virtual void setChannelIndex(unsigned idx);
      virtual void setChannelSelected();

      virtual bool repeatContinuously() const;
      virtual unsigned repetitions() const;
      virtual void setRepetitions(unsigned num);
      virtual void setRepatContinuously();

      virtual unsigned voiceBroadcastDuration() const;
      virtual void setVoiceBroadcastDuration(unsigned min);
      virtual unsigned areaBroadcastDuration() const;
      virtual void setAreaBroadcastDuration(unsigned min);

      virtual bool vox() const;
      virtual void enableVOX(bool enable);
      virtual bool rxAlarm() const;
      virtual void enableRXAlarm(bool enable);
    };
 
  protected:
    AlarmSettingElement(uint8_t *ptr, unsigned size);
 
  public:
    AlarmSettingElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0020; }

    void clear();

    virtual uint8_t *analog() const;
    virtual uint8_t *digital() const;
 
  protected:
    struct Offset {
      static constexpr unsigned int analog()  { return 0x0000; }
      static constexpr unsigned int digital() { return 0x000a; }
    };
  };

  class DigitalAlarmExtensionElement: public Element
  {
  protected:
    DigitalAlarmExtensionElement(uint8_t *ptr, unsigned size);
 
  public:
    DigitalAlarmExtensionElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0030; }

    void clear();

    virtual DMRContact::Type callType() const;
    virtual void setCallType(DMRContact::Type type);

    virtual unsigned destination() const;
    virtual void setDestination(unsigned number);
 
  protected:
    struct Offset {
      static constexpr unsigned int callType()    { return 0x0000; }
      static constexpr unsigned int destination() { return 0x0023; }
    };
  };

  class FiveToneIDElement: public Element
  {
  public:
    enum class Standard {
      ZVEI1 = 0, ZVEI2, ZVEI3, PZVEI, DZVEI, PDZVEI, CCIR1, CCIR2, PCCIR, EEA, EuroSignal, NATEL,
      MODAT, CCITT, EIA
    };
 
  protected:
    FiveToneIDElement(uint8_t *ptr, unsigned size);
 
  public:
    FiveToneIDElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0020; }

    void clear();

    virtual Standard standard() const;
    virtual void setStandard(Standard std);

    virtual unsigned toneDuration() const;
    virtual void setToneDuration(unsigned ms);

    virtual QString id() const;
    virtual void setID(const QString &id);

    virtual QString name() const;
    virtual void setName(const QString &name);
  };

  class FiveToneIDBitmapElement: public BitmapElement
  {
  protected:
    FiveToneIDBitmapElement(uint8_t *ptr, size_t size);
 
  public:
    FiveToneIDBitmapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0010; }
  };

  class FiveToneIDListElement: public Element
  {
  protected:
    FiveToneIDListElement(uint8_t *ptr, size_t size);
 
  public:
    FiveToneIDListElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0c80; }
 
    void clear();

    virtual uint8_t *member(unsigned int n) const;
 
  public:
    struct Limit {
      static constexpr unsigned int numEntries() { return 100; }   
    };
  };

  class FiveToneFunctionElement: public Element
  {
  public:
    enum class Function {
      OpenSquelch=0, CallAll, EmergencyAlarm, RemoteKill, RemoteStun, RemoteWakeup,
      GroupCall
    };

    enum class Response {
      None=0, Tone, ToneRespond
    };
 
  protected:
    FiveToneFunctionElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit FiveToneFunctionElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0020; }

    void clear();

    virtual Function function() const;
    virtual void setFunction(Function function);
    virtual Response response() const;
    virtual void setResponse(Response response);

    virtual QString id() const;
    virtual void setID(const QString &id);

    virtual QString name() const;
    virtual void setName(const QString &name);
  };

  class FiveToneFunctionListElement: public Element
  {
  protected:
    FiveToneFunctionListElement(uint8_t *ptr, size_t size);
 
  public:
    FiveToneFunctionListElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0200; }
 
    void clear();

    virtual uint8_t *function(unsigned int n) const;
 
  public:
    struct Limit {
      static constexpr unsigned int numFunctions() { return 16; }     
    };
  };

  class FiveToneSettingsElement: public Element
  {
  public:
    enum class Response {
      None = 0, Tone, ToneRespond
    };

    typedef enum FiveToneIDElement::Standard Standard;
 
  protected:
    FiveToneSettingsElement(uint8_t *ptr, unsigned size);
 
  public:
    FiveToneSettingsElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0080; }

    void clear();

    virtual Response decodingResponse() const;
    virtual void setDecodingResponse(Response response);

    virtual Standard decodingStandard() const;
    virtual void setDecodingStandard(Standard standard);

    virtual unsigned decodingToneDuration() const;
    virtual void setDecodingToneDuration(unsigned ms);

    virtual QString id() const;
    virtual void setID(const QString &id);

    virtual unsigned postEncodeDelay() const;
    virtual void setPostEncodeDelay(unsigned ms);

    virtual bool hasPTTID() const;
    virtual unsigned pttID() const;
    virtual void setPTTID(unsigned id);
    virtual void clearPTTID();

    virtual unsigned autoResetTime() const;
    virtual void setAutoResetTime(unsigned s);

    virtual unsigned firstDelay() const;
    virtual void setFirstDelay(unsigned ms);

    virtual bool sidetoneEnabled() const;
    virtual void enableSidetone(bool enable);
    virtual unsigned stopCode() const;
    virtual void setStopCode(unsigned code);
    virtual unsigned stopTime() const;
    virtual void setStopTime(unsigned ms);
    virtual unsigned decodeTime() const;
    virtual void setDecodeTime(unsigned ms);
    virtual unsigned delayAfterStop() const;
    virtual void setDelayAfterStop(unsigned ms);
    virtual unsigned preTime() const;
    virtual void setPreTime(unsigned ms);

    virtual Standard botStandard() const;
    virtual void setBOTStandard(Standard standard);
    virtual unsigned botToneDuration() const;
    virtual void setBOTToneDuration(unsigned ms);
    virtual QString botID() const;
    virtual void setBOTID(const QString &id);

    virtual Standard eotStandard() const;
    virtual void setEOTStandard(Standard standard);
    virtual unsigned eotToneDuration() const;
    virtual void setEOTToneDuration(unsigned ms);
    virtual QString eotID() const;
    virtual void setEOTID(const QString &id);
  };

  class TwoToneIDElement: public Element
  {
  protected:
    TwoToneIDElement(uint8_t *ptr, unsigned size);
 
  public:
    TwoToneIDElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0010; }

    void clear();

    virtual double firstTone() const;
    virtual void setFirstTone(double f);

    virtual double secondTone() const;
    virtual void setSecondTone(double f);

    virtual QString name() const;
    virtual void setName(const QString &name);
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength() { return 7; }          
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int firstTone()  { return 0x0000; }
      static constexpr unsigned int secondTone() { return 0x0002; }
      static constexpr unsigned int name()       { return 0x0008; }
    };
  };

  class TwoToneIDBitmapElement: public BitmapElement
  {
  protected:
    TwoToneIDBitmapElement(uint8_t *ptr, size_t size);
 
  public:
    TwoToneIDBitmapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0010; }
  };

  class TwoToneFunctionElement: public Element
  {
  public:
    enum class Response {
      None = 0, Tone, ToneRespond
    };
 
  protected:
    TwoToneFunctionElement(uint8_t *ptr, unsigned size);
 
  public:
    TwoToneFunctionElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0020; }

    void clear();

    virtual double firstTone() const;
    virtual void setFirstTone(double f);

    virtual double secondTone() const;
    virtual void setSecondTone(double f);

    virtual Response response() const;
    virtual void setResponse(Response resp);

    virtual QString name() const;
    virtual void setName(const QString &name);
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength() { return 7; }      
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int firstTone()  { return 0x0000; }
      static constexpr unsigned int secondTone() { return 0x0002; }
      static constexpr unsigned int response()   { return 0x0004; }
      static constexpr unsigned int name()       { return 0x0005; }
    };
  };

  class TwoToneFunctionBitmapElement: public BitmapElement
  {
  protected:
    TwoToneFunctionBitmapElement(uint8_t *ptr, size_t size);
 
  public:
    TwoToneFunctionBitmapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0010; }
  };

  class TwoToneSettingsElement : public Element
  {
  protected:
    TwoToneSettingsElement(uint8_t *ptr, unsigned size);
 
  public:
    TwoToneSettingsElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0010; }

    void clear();

    virtual unsigned firstToneDuration() const;
    virtual void setFirstToneDuration(unsigned ms);

    virtual unsigned secondToneDuration() const;
    virtual void setSecondToneDuration(unsigned ms);

    virtual unsigned longToneDuration() const;
    virtual void setLongToneDuration(unsigned ms);

    virtual unsigned gapDuration() const;
    virtual void setGapDuration(unsigned ms);

    virtual unsigned autoResetTime() const;
    virtual void setAutoResetTime(unsigned sec);

    virtual bool sidetone() const;
    virtual void enableSidetone(bool enable);
  };

  class DTMFSettingsElement: public Element
  {
  public:
    enum Response {
      None=0, Tone, ToneRespond
    };
 
  protected:
    DTMFSettingsElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit DTMFSettingsElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0050; }

    void clear();

    virtual unsigned intervalSymbol() const;
    virtual void setIntervalSymbol(unsigned symb);

    virtual unsigned groupCode() const;
    virtual void setGroupCode(unsigned symb);

    virtual Response response() const;
    virtual void setResponse(Response resp);

    virtual unsigned preTime() const;
    virtual void setPreTime(unsigned ms);

    virtual unsigned firstDigitDuration() const;
    virtual void setFirstDigitDuration(unsigned ms);

    virtual unsigned autoResetTime() const;
    virtual void setAutoResetTime(unsigned sec);

    virtual QString id() const;
    virtual void setID(const QString &id);

    virtual unsigned postEncodingDelay() const;
    virtual void setPostEncodingDelay(unsigned ms);

    virtual unsigned pttIDPause() const;
    virtual void setPTTIDPause(unsigned sec);

    virtual bool pttIDEnabled() const;
    virtual void enablePTTID(bool enable);

    virtual unsigned dCodePause() const;
    virtual void setDCodePause(unsigned sec);

    virtual bool sidetone() const;
    virtual void enableSidetone(bool enable);

    virtual QString botID() const;
    virtual void setBOTID(const QString &id);

    virtual QString eotID() const;
    virtual void setEOTID(const QString &id);

    virtual QString remoteKillID() const;
    virtual void setRemoteKillID(const QString &id);

    virtual QString remoteStunID() const;
    virtual void setRemoteStunID(const QString &id);
  };

  class DTMFIDListElement: public Element
  {
  protected:
    DTMFIDListElement(uint8_t *ptr, size_t size);
 
  public:
    DTMFIDListElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0100; }
 
    void clear();

    virtual bool hasNumber(unsigned int n) const;
    virtual QString number(unsigned int n) const;
    virtual void setNumber(unsigned int n, const QString &number);
    virtual void clearNumber(unsigned int n);
 
  public:
    struct Limit {
      static constexpr unsigned int numEntries()   { return 16; }      
      static constexpr unsigned int numberLength() { return 16; }      
    };
  };

  class WFMChannelListElement: public Element
  {
  protected:
    WFMChannelListElement(uint8_t *ptr, size_t size);
 
  public:
    explicit WFMChannelListElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0200; }
 
    void clear();

    virtual bool hasChannel(unsigned int n) const;
    virtual Frequency channel(unsigned int n) const;
    virtual void setChannel(unsigned int n, Frequency freq);
    virtual void clearChannel(unsigned int n);
 
  public:
    struct Limit {
      static constexpr unsigned int numEntries() { return 100; }     
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int betweenChannels() { return 0x0004; }
    };
  };

  class WFMChannelBitmapElement: public BitmapElement
  {
  protected:
    WFMChannelBitmapElement(uint8_t *ptr, size_t size);
 
  public:
    WFMChannelBitmapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0020; }
  };

  class WFMVFOElement: public Element
  {
  protected:
    WFMVFOElement(uint8_t *ptr, size_t size);
 
  public:
    WFMVFOElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0010; }
 
    void clear();

    virtual Frequency frequency() const;
    virtual void setFrequency(Frequency freq);
  };

  class DMREncryptionKeyIDListElement: public Element
  {
  protected:
    DMREncryptionKeyIDListElement(uint8_t *ptr, size_t size);
 
  public:
    DMREncryptionKeyIDListElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0040; }
 
    void clear();

    virtual bool hasID(unsigned int n) const;
    virtual uint16_t id(unsigned int n) const;
    virtual void setID(unsigned int n, uint16_t id);
    virtual void clearID(unsigned int n);
 
  public:
    struct Limit {
      static constexpr unsigned int numEntries() { return 32; }      
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int betweenIDs() { return 0x0002; }
    };
  };

  class DMREncryptionKeyListElement: public Element
  {
  protected:
    DMREncryptionKeyListElement(uint8_t *ptr, size_t size);
 
  public:
    DMREncryptionKeyListElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0500; }
 
    void clear();

    QByteArray key(unsigned int n) const;
    void setKey(unsigned int n, const QByteArray &key);
 
  public:
    struct Limit {
      static constexpr unsigned numEntries() { return DMREncryptionKeyIDListElement::Limit::numEntries(); } 
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int keys() { return 0x0010; }
      static constexpr unsigned int betweenKeys() { return 0x0028; }
    };
  };

  class ContactMapElement: public Element
  {
  protected:
    ContactMapElement(uint8_t *ptr, unsigned size);
 
  public:
    ContactMapElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0008; }

    void clear();
    bool isValid() const;

    virtual bool isGroup() const;
    virtual unsigned id() const;
    virtual void setID(unsigned id, bool group=false);
    virtual unsigned index() const;
    virtual void setIndex(unsigned idx);
  };
 
protected:
  AnytoneCodeplug(const QString &label, QObject *parent=nullptr);
 
public:
  virtual ~AnytoneCodeplug();

  virtual void clear();
 
  Config *preprocess(Config *config, const ErrorStack &err) const;
  bool encode(Config *config, const Flags &flags, const ErrorStack &err);
 
  bool decode(Config *config, const ErrorStack &err);
  bool postprocess(Config *config, const ErrorStack &err) const;
 
protected:
  virtual bool index(Config *config, Context &ctx, const ErrorStack &err=ErrorStack()) const;

  virtual bool allocateBitmaps() = 0;
  virtual void setBitmaps(Context &ctx) = 0;

  virtual void allocateUpdated() = 0;
  virtual void allocateForDecoding() = 0;
  virtual void allocateForEncoding() = 0;

  virtual bool encodeElements(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodeElements(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
 
protected:
  QString _label;
 
  // Allow access to protected allocation methods.
  friend class AnytoneRadio;
};
 
#endif // ANYTONECODEPLUG_HH