radioddity_codeplug.hh

#ifndef RADIODDITYCODEPLUG_HH
#define RADIODDITYCODEPLUG_HH
 
#include "codeplug.hh"
#include "signaling.hh"
#include "channel.hh"
#include "contact.hh"
#include "radioddity_extensions.hh"
#include "ranges.hh"
#include "bootsettings.hh"
 
 
class DMRContact;
class Zone;
class RXGroupList;
class ScanList;

class RadioddityCodeplug : public Codeplug
{
  Q_OBJECT
 
public:
  class ChannelElement: public Codeplug::Element
  {
  public:
    enum Mode {
      MODE_ANALOG = 0,   
      MODE_DIGITAL = 1   
    };

    enum Admit {
      ADMIT_ALWAYS = 0,  
      ADMIT_CH_FREE = 1, 
      ADMIT_COLOR = 2    
    };

    enum PrivacyGroup {
      PRIVGR_NONE = 0,     
      PRIVGR_53474C39 = 1  
    };
 
  protected:
    ChannelElement(uint8_t *ptr, size_t size);
 
  public:
    explicit ChannelElement(uint8_t *ptr);
    virtual ~ChannelElement();

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

    virtual void clear();

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

    virtual uint32_t rxFrequency() const;
    virtual void setRXFrequency(uint32_t freq);
    virtual uint32_t txFrequency() const;
    virtual void setTXFrequency(uint32_t freq);

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

    virtual Interval txTimeOut() const;
    virtual void setTXTimeOut(const Interval &tot);
    virtual unsigned txTimeOutRekeyDelay() const;
    virtual void setTXTimeOutRekeyDelay(unsigned delay);

    virtual Admit admitCriterion() const;
    virtual void setAdmitCriterion(Admit admit);

    virtual bool hasScanList() const;
    virtual unsigned scanListIndex() const;
    virtual void setScanListIndex(unsigned index);

    virtual SelectiveCall rxTone() const;
    virtual void setRXTone(const SelectiveCall &code);
    virtual SelectiveCall txTone() const;
    virtual void setTXTone(const SelectiveCall &code);

    virtual unsigned txSignalingIndex() const;
    virtual void setTXSignalingIndex(unsigned index);
    virtual unsigned rxSignalingIndex() const;
    virtual void setRXSignalingIndex(unsigned index);

    virtual PrivacyGroup privacyGroup() const;
    virtual void setPrivacyGroup(PrivacyGroup grp);

    virtual unsigned txColorCode() const;
    virtual void setTXColorCode(unsigned cc);

    virtual bool hasGroupList() const;
    virtual unsigned groupListIndex() const;
    virtual void setGroupListIndex(unsigned index);

    virtual unsigned rxColorCode() const;
    virtual void setRXColorCode(unsigned cc);

    virtual bool hasEmergencySystem() const;
    virtual unsigned emergencySystemIndex() const;
    virtual void setEmergencySystemIndex(unsigned index);

    virtual bool hasContact() const;
    virtual unsigned contactIndex() const;
    virtual void setContactIndex(unsigned index);

    virtual bool dataCallConfirm() const;
    virtual void enableDataCallConfirm(bool enable);
    virtual bool emergencyAlarmACK() const;
    virtual void enableEmergencyAlarmACK(bool enable);
    virtual bool privateCallConfirm() const;
    virtual void enablePrivateCallConfirm(bool enable);
    virtual bool privacyEnabled() const;
    virtual void enablePrivacy(bool enable);

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

    virtual bool dualCapacityDirectMode() const;
    virtual void enableDualCapacityDirectMode(bool enable);
    virtual bool nonSTEFrequency() const;
    virtual void enableNonSTEFrequency(bool enable);

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

    virtual bool rxOnly() const;
    virtual void enableRXOnly(bool enable);
    virtual bool talkaround() const;
    virtual void enableTalkaround(bool enable);
    virtual bool vox() const;
    virtual void enableVOX(bool enable);

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

    virtual Channel *toChannelObj(Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool linkChannelObj(Channel *c, Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool fromChannelObj(const Channel *c, Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength() { return 16; }
    };
 
  protected:
    struct Offset: public Element::Offset {
      static constexpr unsigned int name() { return 0x0000; }
      static constexpr unsigned int rxFrequency() { return 0x0010; }
      static constexpr unsigned int txFrequency() { return 0x0014; }
      static constexpr unsigned int mode() { return 0x0018; }
      static constexpr unsigned int txTimeout() { return 0x001b; }
      static constexpr unsigned int txTimeoutRekeyDelay() { return 0x001c; }
      static constexpr unsigned int admitCriterion() { return 0x001d; }
      static constexpr unsigned int scanList() { return 0x001f; }
      static constexpr unsigned int rxTone() { return 0x0020; }
      static constexpr unsigned int txTone() { return 0x0022; }
      static constexpr unsigned int txSignaling() { return 0x0025; }
      static constexpr unsigned int rxSignaling() { return 0x0027; }
      static constexpr unsigned int privacyGroup() { return 0x0029; }
      static constexpr unsigned int txColorCode() { return 0x002a; }
      static constexpr unsigned int groupList() { return 0x002b; }
      static constexpr unsigned int rxColorCode() { return 0x002c; }
      static constexpr unsigned int emergencySystem() { return 0x002d; }
      static constexpr unsigned int transmitContact() { return 0x002e; }
      static constexpr Bit dataCallConfirm() { return {0x0030, 7}; }
      static constexpr Bit emergencyAlarmACK() { return {0x0030, 6}; }
      static constexpr Bit privateCallConfirm() { return {0x0031, 0}; }
      static constexpr Bit privacyEnabled() { return {0x0031, 4}; }
      static constexpr Bit timeSlot() { return {0x0031, 6}; }
      static constexpr Bit dualCapacityDirectMode() { return {0x0032, 0}; }
      static constexpr Bit nonSTEFrequency() { return {0x0032, 5}; }
      static constexpr Bit bandwidth() { return {0x0033, 1}; }
      static constexpr Bit rxOnly() { return {0x0033, 2}; }
      static constexpr Bit talkaround() { return {0x0033, 3}; }
      static constexpr Bit vox() { return {0x0033, 6}; }
      static constexpr Bit power() { return {0x0033, 7}; }
    };
  };

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

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

    void clear();

    virtual bool isEnabled(unsigned idx) const ;
    virtual void enable(unsigned idx, bool enabled);
    virtual uint8_t *get(unsigned idx) const;
    ChannelElement channel(unsigned int n);
 
  public:
    struct Limit {
      static constexpr unsigned int channelCount() { return 128; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int bitmask() { return 0x0000; }
      static constexpr unsigned int channels() { return 0x0010; }
    };
  };

  class VFOChannelElement: public ChannelElement
  {
  public:
    enum class OffsetMode {
      Off = 0,       
      Positive = 1,  
      Negative = 2   
    };

    enum class StepSize {
      SS2_5kHz = 0,  
      SS5kHz = 1,    
      SS6_25kHz = 2, 
      SS10kHz = 3,   
      SS12_5kHz = 4, 
      SS20kHz = 5,   
      SS30kHz = 6,   
      SS50kHz = 7    
    };
 
  protected:
    VFOChannelElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit VFOChannelElement(uint8_t *ptr);
 
    void clear();

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

    virtual double stepSize() const;
    virtual void setStepSize(double kHz);

    virtual OffsetMode offsetMode() const;
    virtual double txOffset() const;
    virtual void setTXOffset(double f);
    virtual void setOffsetMode(OffsetMode mode);
 
  protected:
    struct Offset: public ChannelElement::Offset {
      static constexpr Bit stepSize()                         { return {0x0036, 4} ; }
      static constexpr Bit offsetMode()                       { return {0x0036, 2} ; }
      static constexpr unsigned int txOffset()                { return 0x0034; }
    };
  };
 

  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 0x0018; }

    void clear();
    bool isValid() const;

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

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

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

    virtual bool ring() const;
    virtual void enableRing(bool enable);

    virtual unsigned ringStyle() const;
    virtual void setRingStyle(unsigned style);

    virtual DMRContact *toContactObj(Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool fromContactObj(const DMRContact *obj, Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength() { return 16; }
      static constexpr unsigned int ringStyle() { return 10; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int name() { return 0x0000; }
      static constexpr unsigned int number() { return 0x0010; }
      static constexpr unsigned int type() { return 0x0014; }
      static constexpr unsigned int ring() { return 0x0015; }
      static constexpr unsigned int ringStyle() { return 0x0016; }
    };
  };
 

  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 0x0020; }

    void clear();
    bool isValid() const;

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

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

    virtual DTMFContact *toContactObj(Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool fromContactObj(const DTMFContact *obj, Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength() { return 16; }
      static constexpr unsigned int numberLength() { return 16; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int name() { return 0x0000; }
      static constexpr unsigned int number() { return 0x0010; }
    };
  };

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

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

    void clear();
    bool isValid() const;

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

    virtual bool hasMember(unsigned n) const;
    virtual unsigned member(unsigned n) const;
    virtual void setMember(unsigned n, unsigned idx);
    virtual void clearMember(unsigned n);

    virtual Zone *toZoneObj(Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool linkZoneObj(Zone *zone, Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool fromZoneObjA(const Zone *zone, Context &ctx, const ErrorStack &err=ErrorStack());
    virtual bool fromZoneObjB(const Zone *zone, Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength() { return 16; }
      static constexpr unsigned int memberCount() { return 16; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int name()  { return 0x0000; }
      static constexpr unsigned int channels() { return 0x0010; }
      static constexpr unsigned int betweenChannels() { return 0x0002; }
    };
 
  };

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

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

    void clear();

    virtual bool isEnabled(unsigned idx) const ;
    virtual void enable(unsigned idx, bool enabled);

    virtual uint8_t *get(unsigned idx) const;
    ZoneElement zone(unsigned int n);
 
  public:
    struct Limit {
      static constexpr unsigned int zoneCount() { return 250; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int bitmap() { return 0x0000; }
      static constexpr unsigned int zones()  { return 0x0020; }
    };
  };

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

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

    void clear();

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

    virtual bool hasMember(unsigned n) const;
    virtual unsigned member(unsigned n) const;
    virtual void setMember(unsigned n, unsigned idx);
    virtual void clearMember(unsigned n);

    virtual RXGroupList *toRXGroupListObj(Context &ctx, const ErrorStack &err = ErrorStack());
    virtual bool linkRXGroupListObj(unsigned int ncnt, RXGroupList *lst, Context &ctx, const ErrorStack &err = ErrorStack()) const;
    virtual bool fromRXGroupListObj(const RXGroupList *lst, Context &ctx, const ErrorStack &err = ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength()  { return 16; }   
      static constexpr unsigned int memberCount() { return 16; }  
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int name()           { return 0x0000; }
      static constexpr unsigned int members()        { return 0x0010; }
      static constexpr unsigned int betweenMembers() { return 0x0002; }
    };
  };

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

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

    void clear();

    virtual bool isEnabled(unsigned n) const;
    virtual unsigned contactCount(unsigned n) const;
    virtual void setContactCount(unsigned n, unsigned size);
    virtual void disable(unsigned n);

    virtual uint8_t *get(unsigned n) const;
 
  public:
    struct Limit {
      static constexpr unsigned int groupListCount() { return 64; }   
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int contactCounts() { return 0x0000; }
      static constexpr unsigned int groupLists() { return 0x0080; }
    };
  };

  class ScanListElement: public Element
  {
  public:
    enum Mode {
      PL_NONPRI = 0,              
      PL_DISABLE = 1,             
      PL_PRI = 2,                 
      PL_PRI_NONPRI = 3           
    };
 
  protected:
    ScanListElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit ScanListElement(uint8_t *ptr);
    virtual ~ScanListElement();

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

    void clear();

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

    virtual bool channelMark() const;
    virtual void enableChannelMark(bool enable);

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

    virtual bool talkback() const;
    virtual void enableTalkback(bool enable);

    virtual bool hasMember(unsigned n) const;
    virtual bool isSelected(unsigned n) const;
    virtual unsigned member(unsigned n) const;
    virtual void setMember(unsigned n, unsigned idx);
    virtual void setSelected(unsigned n);
    virtual void clearMember(unsigned n);

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

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

    virtual bool hasRevert() const;
    virtual bool revertIsSelected() const;
    virtual unsigned revert() const;
    virtual void setRevert(unsigned idx);
    virtual void setRevertSelected();
    virtual void clearRevert();

    virtual unsigned holdTime() const;
    virtual void setHoldTime(unsigned ms);

    virtual unsigned prioritySampleTime() const;
    virtual void setPrioritySampleTime(unsigned ms);

    virtual ScanList *toScanListObj(Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool linkScanListObj(ScanList *lst, Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool fromScanListObj(const ScanList *lst, Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit: public Element::Limit {
      static constexpr unsigned int name()                    { return 15; }
      static constexpr unsigned int members()                 { return 32; }
    };
 
  protected:
    struct Offset: public Element::Offset {
      static constexpr unsigned int name()                    { return 0x0000; }
      static constexpr Bit channelMark()                      { return {0x000f, 4}; }
      static constexpr Bit mode()                             { return {0x000f, 6}; }
      static constexpr Bit talkback()                         { return {0x000f, 7}; }
      static constexpr unsigned int members()                 { return 0x0010; }
      static constexpr unsigned int betweenMembers()          { return 0x0002; }
      static constexpr unsigned int primary()                 { return 0x0050; }
      static constexpr unsigned int secondary()               { return 0x0052; }
      static constexpr unsigned int revert()                  { return 0x0054; }
      static constexpr unsigned int holdTime()                { return 0x0056; }
      static constexpr unsigned int primaryHoldTime()         { return 0x0057; }
    };
  };

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

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

    void clear();

    virtual bool isEnabled(unsigned n) const;
    virtual void enable(unsigned n, bool enabled);
    virtual uint8_t *get(unsigned n) const;
 
  public:
    struct Limit {
      static constexpr unsigned int scanListCount() { return 250; } 
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int bytemap()   { return 0x0000; }
      static constexpr unsigned int scanLists() { return 0x0040; }
    };
  };
 

  class GeneralSettingsElement: public Element
  {
  public:
    typedef RadiodditySettingsExtension::MonitorType MonitorType;
    typedef RadioddityToneSettingsExtension::ARTSTone ARTSTone;
    typedef RadiodditySettingsExtension::ScanMode ScanMode;
 
  protected:
    GeneralSettingsElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit GeneralSettingsElement(uint8_t *ptr);
    virtual ~GeneralSettingsElement();

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

    void clear();

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

    virtual unsigned radioID() const;
    virtual void setRadioID(unsigned id);

    virtual Interval preambleDuration() const;
    virtual void setPreambleDuration(const Interval &dur);

    virtual MonitorType monitorType() const;
    virtual void setMonitorType(MonitorType type);

    virtual Level voxSensitivity() const;
    virtual void setVOXSensitivity(Level value);

    virtual unsigned lowBatteryWarnInterval() const;
    virtual void setLowBatteryWarnInterval(unsigned sec);

    virtual unsigned callAlertDuration() const;
    virtual void setCallAlertDuration(unsigned sec);

    virtual unsigned loneWorkerResponsePeriod() const;
    virtual void setLoneWorkerResponsePeriod(unsigned min);
    virtual unsigned loneWorkerReminderPeriod() const;
    virtual void setLoneWorkerReminderPeriod(unsigned sec);

    virtual Interval groupCallHangTime() const;
    virtual void setGroupCallHangTime(const Interval &dur);
    virtual Interval privateCallHangTime() const;
    virtual void setPrivateCallHangTime(const Interval &dur);

    virtual bool downChannelModeVFO() const;
    virtual void enableDownChannelModeVFO(bool enable);
    virtual bool upChannelModeVFO() const;
    virtual void enableUpChannelModeVFO(bool enable);
    virtual bool resetTone() const;
    virtual void enableResetTone(bool enable);
    virtual bool unknownNumberTone() const;
    virtual void enableUnknownNumberTone(bool enable);
    virtual ARTSTone artsToneMode() const;
    virtual void setARTSToneMode(ARTSTone mode);

    virtual bool digitalTalkPermitTone() const;
    virtual void enableDigitalTalkPermitTone(bool enable);
    virtual bool analogTalkPermitTone() const;
    virtual void enableAnalogTalkPermitTone(bool enable);
    virtual bool selftestTone() const;
    virtual void enableSelftestTone(bool enable);
    virtual bool channelFreeIndicationTone() const;
    virtual void enableChannelFreeIndicationTone(bool enable);
    virtual bool allTonesDisabled() const;
    virtual void disableAllTones(bool disable);
    virtual bool batsaveRX() const;
    virtual void enableBatsaveRX(bool enable);
    virtual bool batsavePreamble() const;
    virtual void enableBatsavePreamble(bool enable);

    virtual bool allLEDsDisabled() const;
    virtual void disableAllLEDs(bool disable);
    virtual bool quickKeyOverrideInhibited() const;
    virtual void inhibitQuickKeyOverride(bool inhibit);

    virtual bool txExitTone() const;
    virtual void enableTXExitTone(bool enable);
    virtual bool txOnActiveChannel() const;
    virtual void enableTXOnActiveChannel(bool enable);
    virtual bool animation() const;
    virtual void enableAnimation(bool enable);
    virtual ScanMode scanMode() const;
    virtual void setScanMode(ScanMode mode);

    virtual unsigned repeaterEndDelay() const;
    virtual void setRepeaterEndDelay(unsigned delay);
    virtual unsigned repeaterSTE() const;
    virtual void setRepeaterSTE(unsigned ste);

    virtual bool hasProgPassword() const;
    virtual QString progPassword() const;
    virtual void setProgPassword(const QString &pwd);
    virtual void clearProgPassword();

    virtual bool fromConfig(Context &ctx, const ErrorStack &err=ErrorStack());
    virtual bool updateConfig(Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit: Element::Limit {
      // VOX sensitivity settings.
      static constexpr Range<unsigned int> vox() { return {1,10}; }
    };
  };

  class ButtonSettingsElement: public Element
  {
  public:
    struct KeyFunction {
    public:
      static uint8_t encode(RadioddityButtonSettingsExtension::Function func);
      static RadioddityButtonSettingsExtension::Function decode(uint8_t action);
 
    protected:
      enum Action {
        None                   = 0x00,  
        ToggleAllAlertTones    = 0x01,
        EmergencyOn            = 0x02,
        EmergencyOff           = 0x03,
        ToggleMonitor          = 0x05,  
        NuiaceDelete           = 0x06,
        OneTouch1              = 0x07,  
        OneTouch2              = 0x08,  
        OneTouch3              = 0x09,  
        OneTouch4              = 0x0a,  
        OneTouch5              = 0x0b,  
        OneTouch6              = 0x0c,  
        ToggleRepeatTalkaround = 0x0d,
        ToggleScan             = 0x0e,
        TogglePrivacy          = 0x10,
        ToggleVox              = 0x11,
        ZoneSelect             = 0x12,
        BatteryIndicator       = 0x13,
        ToggleLoneWorker       = 0x14,
        PhoneExit              = 0x16,
        ToggleFlashLight       = 0x1a,
        ToggleFMRadio          = 0x1b
      };
    };

    enum class OneTouchAction {
      None                   = 0x00,  
      DigitalCall            = 0x10,  
      DigitalMessage         = 0x11,  
      AnalogCall             = 0x20   
    };
 
  protected:
    ButtonSettingsElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit ButtonSettingsElement(uint8_t *ptr);
    virtual ~ButtonSettingsElement();

    void clear();

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

    virtual RadioddityButtonSettingsExtension::Function sk1ShortPress() const;
    virtual void setSK1ShortPress(RadioddityButtonSettingsExtension::Function action);
    virtual RadioddityButtonSettingsExtension::Function sk1LongPress() const;
    virtual void setSK1LongPress(RadioddityButtonSettingsExtension::Function action);

    virtual RadioddityButtonSettingsExtension::Function sk2ShortPress() const;
    virtual void setSK2ShortPress(RadioddityButtonSettingsExtension::Function action);
    virtual RadioddityButtonSettingsExtension::Function sk2LongPress() const;
    virtual void setSK2LongPress(RadioddityButtonSettingsExtension::Function action);

    virtual RadioddityButtonSettingsExtension::Function tkShortPress() const;
    virtual void setTKShortPress(RadioddityButtonSettingsExtension::Function action);
    virtual RadioddityButtonSettingsExtension::Function tkLongPress() const;
    virtual void setTKLongPress(RadioddityButtonSettingsExtension::Function action);

    virtual OneTouchAction oneTouchAction(unsigned n) const;
    virtual unsigned oneTouchContact(unsigned n) const;
    virtual unsigned oneTouchMessage(unsigned n) const;
    virtual void disableOneTouch(unsigned n);
    virtual void setOneTouchDigitalCall(unsigned n, unsigned index);
    virtual void setOneTouchDigitalMessage(unsigned n, unsigned index);
    virtual void setOneTouchAnalogCall(unsigned n);

    bool encode(Context &ctx, const ErrorStack &err=ErrorStack());
    bool decode(Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limits {
      static constexpr TimeRange longPressDuration() {
        return TimeRange{Interval::fromMilliseconds(0), Interval::fromMilliseconds(255*250)};
      }

      static constexpr unsigned int oneTouchActions() { return 6; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int longPressDuration()      { return 0x0001; }
      static constexpr unsigned int sk1ShortPress()          { return 0x0002; }
      static constexpr unsigned int sk1LongPress()           { return 0x0003; }
      static constexpr unsigned int sk2ShortPress()          { return 0x0004; }
      static constexpr unsigned int sk2LongPress()           { return 0x0005; }
      static constexpr unsigned int tkShortPress()           { return 0x0006; }
      static constexpr unsigned int tkLongPress()            { return 0x0007; }
      static constexpr unsigned int oneTouchActions()        { return 0x0008; }
      static constexpr unsigned int betweenOneTouchActions() { return 0x0004; }
    };
  };

  class MenuSettingsElement: public Element
  {
  public:
    enum class ChannelDisplayMode {
      Number    = 0,  
      Name      = 1,  
      Frequency = 2   
    };

    enum class DualWatchMode {
      DualDual = 1,
      DualSingle = 2
    };
 
  protected:
    MenuSettingsElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit MenuSettingsElement(uint8_t *ptr);
    virtual ~MenuSettingsElement();

    void clear();

    virtual unsigned menuHangTime() const;
    virtual void setMenuHangTime(unsigned sec);

    virtual bool message() const;
    virtual void enableMessage(bool enable);
    virtual bool scanStart() const;
    virtual void enableScanStart(bool enable);
    virtual bool editScanList() const;
    virtual void enableEditScanList(bool enable);
    virtual bool callAlert() const;
    virtual void enableCallAlert(bool enable);
    virtual bool editContact() const;
    virtual void enableEditContact(bool enable);
    virtual bool manualDial() const;
    virtual void enableManualDial(bool enable);
    virtual bool radioCheck() const;
    virtual void enableRadioCheck(bool enable);
    virtual bool remoteMonitor() const;
    virtual void enableRemoteMonitor(bool enable);

    virtual bool radioEnable() const;
    virtual void enableRadioEnable(bool enable);
    virtual bool radioDisable() const;
    virtual void enableRadioDisable(bool enable);
    virtual bool progPassword() const;
    virtual void enableProgPassword(bool enable);
    virtual bool talkaround() const;
    virtual void enableTalkaround(bool enable);
    virtual bool tone() const;
    virtual void enableTone(bool enable);
    virtual bool power() const;
    virtual void enablePower(bool enable);
    virtual bool backlight() const;
    virtual void enableBacklight(bool enable);
    virtual bool introScreen() const;
    virtual void enableIntroScreen(bool enable);

    virtual bool keypadLock() const;
    virtual void enableKeypadLock(bool enable);
    virtual bool ledIndicator() const;
    virtual void enableLEDIndicator(bool enable);
    virtual bool squelch() const;
    virtual void enableSquelch(bool enable);
    virtual bool privacy() const;
    virtual void enablePrivacy(bool enable);
    virtual bool vox() const;
    virtual void enableVOX(bool enable);
    virtual bool passwordLock() const;
    virtual void enablePasswordLock(bool enable);
    virtual bool missedCalls() const;
    virtual void enableMissedCalls(bool enable);
    virtual bool answeredCalls() const;
    virtual void enableAnsweredCalls(bool enable);

    virtual bool outgoingCalls() const;
    virtual void enableOutgoingCalls(bool enable);
    virtual bool channelDisplay() const;
    virtual void enableChannelDisplay(bool enable);
    virtual bool dualWatch() const;
    virtual void enableDualWatch(bool enable);

    virtual unsigned keypadLockTime() const;
    virtual void setKeypadLockTime(unsigned sec);

    virtual unsigned backlightTime() const;
    virtual void setBacklightTime(unsigned sec);

    virtual ChannelDisplayMode channelDisplayMode() const;
    virtual void setChannelDisplayMode(ChannelDisplayMode mode);

    virtual bool keyTone() const;
    virtual void enableKeyTone(bool enable);

    virtual DualWatchMode dualWatchMode() const;
    virtual void setDualWatchMode(DualWatchMode mode);
  };

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

    void clear();

    virtual BootSettings::BootDisplay bootDisplay() const;
    virtual void setBootDisplay(BootSettings::BootDisplay mode);

    virtual bool bootPasswordEnabled() const;
    virtual void enableBootPassword(bool enable);
    virtual QString bootPassword() const;
    virtual bool setBootPassword(const QString &passwd);

    virtual bool decode(Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool encode(Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit: Element::Limit {
      // Maximum password length.
      static constexpr unsigned passwordLength() { return 8; }
    };
 
  protected:
    struct Offset: Element::Offset {
      static constexpr unsigned int bootText() { return 0x0000; }
      static constexpr unsigned int bootPasswordEnable() { return 0x0001; }
      static constexpr unsigned int bootPassword() { return 0x0002; }
    };
  };
 

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

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

    void clear();

    virtual QString line1() const;
    virtual void setLine1(const QString &text);
    virtual QString line2() const;
    virtual void setLine2(const QString &text);

    virtual bool fromConfig(Context &ctx, const ErrorStack &err = ErrorStack());
    virtual bool updateConfig(Context &ctx, const ErrorStack &err = ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int lineLength() { return 16; }  
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int line1() { return 0x0000;}
      static constexpr unsigned int line2() { return 0x0010;}
    };
  };

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

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

    virtual unsigned numMessages() const;
    virtual QString message(unsigned n) const;
    virtual void appendMessage(const QString msg);

    virtual bool encode(Context &ctx, const Flags &flags, const ErrorStack &err=ErrorStack());
    virtual bool decode(Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int messages()      { return 32; }   
      static constexpr unsigned int messageLength() { return 144; }  
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int messageConut()    { return 0x0000; }
      static constexpr unsigned int messageLengths()  { return 0x0008; }
      static constexpr unsigned int messages()        { return 0x0048; }
      static constexpr unsigned int betweenMessages() { return Limit::messageLength(); }
    };
  };

  class EncryptionElement: public Codeplug::Element
  {
  public:
    enum class PrivacyType {
      None,   
      Basic   
    };
 
  protected:
    EncryptionElement(uint8_t *ptr, size_t size);
 
  public:
    explicit EncryptionElement(uint8_t *ptr);
    virtual ~EncryptionElement();

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

    virtual PrivacyType privacyType() const;
    virtual void setPrivacyType(PrivacyType type);

    virtual bool isBasicKeySet(unsigned n) const;
    virtual QByteArray basicKey(unsigned n) const;
    virtual void setBasicKey(unsigned n, const QByteArray &key);
    virtual void clearBasicKey(unsigned n);

    virtual bool fromCommercialExt(CommercialExtension *ext, Context &ctx, const ErrorStack &err=ErrorStack());
    virtual bool updateCommercialExt(Context &ctx, const ErrorStack &err=ErrorStack());
    virtual bool linkCommercialExt(CommercialExtension *ext, Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int keyCount() { return 16; }
      static constexpr unsigned int keySize() { return 4; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int privacyType() { return 0x0000; }
      static constexpr unsigned int bitmap() { return 0x0002; }
      static constexpr unsigned int keys() { return 0x0008; }         
      static constexpr unsigned int key() { return 0x0008;}           
    };
  };
 
protected:
  explicit RadioddityCodeplug(QObject *parent=nullptr);
 
public:
  virtual ~RadioddityCodeplug();

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

  virtual void clearGeneralSettings() = 0;
  virtual bool encodeGeneralSettings(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodeGeneralSettings(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearButtonSettings() = 0;
  virtual bool encodeButtonSettings(Context &ctx, const Flags &flags, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodeButtonSettings(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearMessages() = 0;
  virtual bool encodeMessages(Context &ctx, const Flags &flags, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodeMessages(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearContacts() = 0;
  virtual bool encodeContacts(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createContacts(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearDTMFContacts() = 0;
  virtual bool encodeDTMFContacts(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createDTMFContacts(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearChannels() = 0;
  virtual bool encodeChannels(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createChannels(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool linkChannels(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearMenuSettings() = 0;

  virtual void clearBootSettings() = 0;
  virtual bool encodeBootSettings(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodeBootSettings(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearVFOSettings() = 0;

  virtual void clearZones() = 0;
  virtual bool encodeZones(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createZones(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool linkZones(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearScanLists() = 0;
  virtual bool encodeScanLists(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createScanLists(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool linkScanLists(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearGroupLists() = 0;
  virtual bool encodeGroupLists(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createGroupLists(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool linkGroupLists(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearEncryption() = 0;
  virtual bool encodeEncryption(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createEncryption(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool linkEncryption(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
};
 
#endif // RADIODDITYCODEPLUG_HH