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"
 
 
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 unsigned txTimeOut() const;
    virtual void setTXTimeOut(unsigned 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 unsigned preambleDuration() const;
    virtual void setPreambleDuration(unsigned ms);
 
    virtual MonitorType monitorType() const;
    virtual void setMonitorType(MonitorType type);
 
    virtual unsigned voxSensitivity() const;
    virtual void setVOXSensitivity(unsigned 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 unsigned groupCallHangTime() const;
    virtual void setGroupCallHangTime(unsigned ms);
    virtual unsigned privateCallHangTime() const;
    virtual void setPrivateCallHangTime(unsigned ms);
 
    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());
  };
 
  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 bool bootText() const;
    virtual void enableBootText(bool enable);
 
    virtual bool bootPasswordEnabled() const;
    virtual void enableBootPassword(bool enable);
    virtual unsigned bootPassword() const;
    virtual void setBootPassword(unsigned passwd);
  };
 
  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 clearBootSettings() = 0;
 
  virtual void clearMenuSettings() = 0;
 
  virtual void clearBootText() = 0;
  virtual bool encodeBootText(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodeBootText(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