gd73_codeplug.hh

#ifndef GD73CODEPLUG_HH
#define GD73CODEPLUG_HH
 
#include "codeplug.hh"
#include "interval.hh"
#include "ranges.hh"
#include "contact.hh"
#include "rxgrouplist.hh"
#include "channel.hh"
#include "zone.hh"
#include "radioddity_extensions.hh"
 
 
class SMSTemplate;
class SMSExtension;
 
class GD73Codeplug : public Codeplug
{
  Q_OBJECT
 
public:
  class InformationElement: public Element
  {
  protected:
    InformationElement(uint8_t *ptr, size_t size);
 
  public:
    InformationElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x0061; }
 
    FrequencyRange frequencyRange() const;
    void setFrequencyRange(const FrequencyRange &range);
 
    QDateTime timestamp() const;
    void setTimestamp(const QDateTime &timestamp);
 
    QString serial() const;
    QString modelName() const;
    QString deviceID() const;
    QString modelNumber() const;
    QString softwareVersion() const;
 
  public:
    struct Limit {
      static constexpr unsigned int serial()                                { return 16; }
      static constexpr unsigned int modelName()                             { return 16; }
      static constexpr unsigned int deviceID()                              { return 16; }
      static constexpr unsigned int modelNumber()                           { return 16; }
      static constexpr unsigned int softwareVersion()                       { return 16; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int frequencyRange()                        { return 0x0000; }
      static constexpr unsigned int dateCentury()                           { return 0x0001; }
      static constexpr unsigned int dateYear()                              { return 0x0002; }
      static constexpr unsigned int dateMonth()                             { return 0x0003; }
      static constexpr unsigned int dateDay()                               { return 0x0004; }
      static constexpr unsigned int dateHour()                              { return 0x0005; }
      static constexpr unsigned int dateMinute()                            { return 0x0006; }
      static constexpr unsigned int dateSecond()                            { return 0x0007; }
      static constexpr unsigned int serial()                                { return 0x0011; }
      static constexpr unsigned int modelName()                             { return 0x0021; }
      static constexpr unsigned int deviceID()                              { return 0x0031; }
      static constexpr unsigned int modelNumber()                           { return 0x0041; }
      static constexpr unsigned int softwareVersion()                       { return 0x0051; }
    };
  };
 
 
  class OneTouchSettingElement: public Element
  {
  public:
    enum class Action {
      Call = 0, Message = 1
    };
 
  protected:
    OneTouchSettingElement(uint8_t *ptr, size_t size);
 
  public:
    OneTouchSettingElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x0005; }
 
  protected:
    struct Offset {
      static constexpr unsigned int contact()                               { return 0x0001; }
      static constexpr unsigned int action()                                { return 0x0003; }
      static constexpr unsigned int message()                               { return 0x0001; }
    };
  };
 
 
  class SettingsElement: public Element
  {
  public:
    enum class ChannelDisplayMode {
      Name = 0, Frequency = 1
    };
    enum class BootDisplayMode {
      Off = 0, Text = 1, Image = 2, Both = 3
    };
    struct KeyFunction {
    public:
      static uint8_t encode(RadioddityButtonSettingsExtension::Function func);
      static RadioddityButtonSettingsExtension::Function decode(uint8_t code);
    protected:
      enum Code {
        None=0, RadioEnable=1, RadioCheck=2, RadioDisable=3, PowerLevel=4,
        Monitor=5, EmergencyOn=6, EmergencyOff=7, ZoneSwitch=8, ToggleScan=9, ToggleVOX=10,
        OneTouch1=11, OneTouch2=12, OneTouch3=13, OneTouch4=14, OneTouch5=15, ToggleTalkaround=16,
        LoneWorker=17, TBST=18, CallSwell=19
      };
    };
    enum class Language {
      Chinese=0, English=1
    };
 
  protected:
    SettingsElement(uint8_t *ptr, size_t size);
 
  public:
    SettingsElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x00aa; }
 
    QString name() const;
    void setName(const QString &name);
 
    unsigned int dmrID() const;
    void setDMRID(unsigned int id);
 
    Language language() const;
    void setLanguage(Language lang);
 
    unsigned int vox() const;
    void setVOX(unsigned int level);
 
    unsigned int squelch() const;
    void setSquelch(unsigned int level);
 
    bool totIsSet() const;
    Interval tot() const;
    void setTOT(const Interval &interval);
    void clearTOT();
 
    bool txInterruptedEnabled() const;
    void enableTXInterrupt(bool enable);
 
    bool powerSaveEnabled() const;
    void enablePowerSave(bool enable);
    Interval powerSaveTimeout() const;
    void setPowerSaveTimeout(const Interval &interval);
 
    bool readLockEnabled() const;
    void enableReadLock(bool enable);
    QString readLockPin() const;
    void setReadLockPin(const QString &pin);
 
    bool writeLockEnabled() const;
    void enableWriteLock(bool enable);
    QString writeLockPin() const;
    void setWriteLockPin(const QString &pin);
 
    ChannelDisplayMode channelDisplayMode() const;
    void setChannelDisplayMode(ChannelDisplayMode mode);
 
    unsigned int dmrMicGain() const;
    void setDMRMicGain(unsigned int gain);
    unsigned int fmMicGain() const;
    void setFMMicGain(unsigned int gain);
 
    Interval loneWorkerResponseTimeout() const;
    void setLoneWorkerResponseTimeout(const Interval &interval);
    Interval loneWorkerRemindPeriod() const;
    void setLoneWorkerRemindPeriod(const Interval &interval);
 
    BootDisplayMode bootDisplayMode() const;
    void setBootDisplayMode(BootDisplayMode mode);
    QString bootTextLine1() const;
    void setBootTextLine1(const QString &line);
    QString bootTextLine2() const;
    void setBootTextLine2(const QString &line);
 
    bool keyToneEnabled() const;
    void enableKeyTone(bool enable);
    unsigned int keyToneVolume() const;
    void setKeyToneVolume(unsigned int vol);
    bool lowBatteryToneEnabled() const;
    void enableLowBatteryTone(bool enable);
    unsigned int lowBatteryToneVolume() const;
    void setLowBatteryToneVolume(unsigned int vol);
 
    Interval longPressDuration() const;
    void setLongPressDuration(const Interval &interval);
    RadioddityButtonSettingsExtension::Function keyFunctionLongPressP1() const;
    void setKeyFunctionLongPressP1(RadioddityButtonSettingsExtension::Function function);
    RadioddityButtonSettingsExtension::Function keyFunctionShortPressP1() const;
    void setKeyFunctionShortPressP1(RadioddityButtonSettingsExtension::Function function);
    RadioddityButtonSettingsExtension::Function keyFunctionLongPressP2() const;
    void setKeyFunctionLongPressP2(RadioddityButtonSettingsExtension::Function function);
    RadioddityButtonSettingsExtension::Function keyFunctionShortPressP2() const;
    void setKeyFunctionShortPressP2(RadioddityButtonSettingsExtension::Function function);
    OneTouchSettingElement oneTouch(unsigned int n);
 
    bool updateConfig(Context &ctx, const ErrorStack &err=ErrorStack());
    bool encode(Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int name() { return 16; }
      static constexpr TimeRange tot() {
        return TimeRange{Interval::fromSeconds(20), Interval::fromSeconds(500)};
      }
      static constexpr TimeRange powerSaveTimeout() {
        return TimeRange{Interval::fromSeconds(10), Interval::fromSeconds(60)};
      }
      static constexpr unsigned int pin() { return 6; }
      static constexpr TimeRange loneWorkerResponse() {
        return TimeRange{Interval::fromMinutes(1), Interval::fromMinutes(480)};
      }
      static constexpr TimeRange loneWorkerRemindPeriod() {
        return TimeRange{Interval::fromSeconds(10), Interval::fromSeconds(200)};
      }
      static constexpr unsigned int bootTextLine() { return 16; }
      static constexpr IntRange toneVolume() { return IntRange{0,13}; }
      static constexpr TimeRange longPressDuration() {
        return TimeRange{Interval::fromSeconds(0), Interval::fromSeconds(31)};
      }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int name()                                  { return 0x0000; }
      static constexpr unsigned int dmrId()                                 { return 0x0020; }
      static constexpr unsigned int language()                              { return 0x0024; }
      static constexpr unsigned int voxLevel()                              { return 0x0026; }
      static constexpr unsigned int squelchLevel()                          { return 0x0027; }
      static constexpr unsigned int tot()                                   { return 0x0028; }
      static constexpr unsigned int txInterrupt()                           { return 0x0029; }
      static constexpr unsigned int powerSave()                             { return 0x002a; }
      static constexpr unsigned int powerSaveTimeout()                      { return 0x002b; }
      static constexpr unsigned int readLockEnable()                        { return 0x002c; }
      static constexpr unsigned int writeLockEnable()                       { return 0x002d; }
      static constexpr unsigned int channelDisplayMode()                    { return 0x002f; }
      static constexpr unsigned int readLockPin()                           { return 0x0030; }
      static constexpr unsigned int writeLockPin()                          { return 0x0036; }
      static constexpr unsigned int dmrMicGain()                            { return 0x003d; }
      static constexpr unsigned int fmMicGain()                             { return 0x003f; }
      static constexpr unsigned int loneWorkerResponseTimeout()             { return 0x0040; }
      static constexpr unsigned int loneWorkerReminderPeriod()              { return 0x0042; }
      static constexpr unsigned int bootDisplayMode()                       { return 0x0043; }
      static constexpr unsigned int bootTextLine1()                         { return 0x0044; }
      static constexpr unsigned int bootTextLine2()                         { return 0x0064; }
      static constexpr unsigned int keyToneEnable()                         { return 0x0084; }
      static constexpr unsigned int keyToneVolume()                         { return 0x0085; }
      static constexpr unsigned int lowBatToneEnable()                      { return 0x0086; }
      static constexpr unsigned int lowBatToneVolume()                      { return 0x0087; }
      static constexpr unsigned int longPressDuration()                     { return 0x0088; }
      static constexpr unsigned int progFuncKey1ShortPress()                { return 0x008b; }
      static constexpr unsigned int progFuncKey1LongPress()                 { return 0x008c; }
      static constexpr unsigned int progFuncKey2ShortPress()                { return 0x008d; }
      static constexpr unsigned int progFuncKey2LongPress()                 { return 0x008e; }
      static constexpr unsigned int oneTouchSettings()                      { return 0x0090; }
      static constexpr unsigned int betweenOneTouchSettings()               { return OneTouchSettingElement::size(); }
    };
  };
 
 
  class ZoneElement: public Element
  {
  protected:
    ZoneElement(uint8_t *ptr, size_t size);
 
  public:
    ZoneElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x0031; }
 
    QString name() const;
    void setName(const QString &name);
 
    Zone *toZone(Context &ctx, const ErrorStack &err=ErrorStack());
    bool linkZone(Zone *zone, Context &ctx, const ErrorStack &err=ErrorStack());
    bool encode(Zone *zone, Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength()                            { return 8; }
      static constexpr unsigned int channelCount()                          { return 16; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int name()                                  { return 0x0000; }
      static constexpr unsigned int channeCount()                           { return 0x0010; }
      static constexpr unsigned int channelIndices()                        { return 0x0011; }
      static constexpr unsigned int betweenChannelIndices()                 { return 0x0002; }
    };
  };
 
 
  class ZoneBankElement: public Element
  {
  protected:
    ZoneBankElement(uint8_t *ptr, size_t size);
 
  public:
    ZoneBankElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x0c41; }
 
    bool createZones(Context &ctx, const ErrorStack &err);
    bool linkZones(Context &ctx, const ErrorStack &err);
    bool encode(Context &ctx, const ErrorStack &err);
 
  public:
    struct Limit {
      static constexpr unsigned int zoneCount()                             { return 64; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int zoneCount()                             { return 0x0000; }
      static constexpr unsigned int zones()                                 { return 0x0001; }
      static constexpr unsigned int betweenZones()                          { return ZoneElement::size(); }
    };
  };
 
 
  class ChannelElement: public Element
  {
  protected:
    ChannelElement(uint8_t *ptr, size_t size);
 
  public:
    enum class Type {
      FM = 0, DMR = 1
    };
    enum class Admit {
      Always = 0, CC_CTCSS = 1, Free=2
    };
 
  public:
    ChannelElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x0046; }
 
    QString name() const;
    void setName(const QString &name);
 
    FMChannel::Bandwidth bandwidth() const;
    void setBandwidth(FMChannel::Bandwidth bandwidth);
 
    bool hasScanListIndex() const;
    unsigned int scanListIndex() const;
    void setScanListIndex(unsigned int idx);
    void clearScanListIndex();
 
    Type type() const;
    void setType(Type type);
 
    bool talkaroundEnabled() const;
    void enableTalkaround(bool enable);
 
    bool rxOnly() const;
    void enableRXOnly(bool enable);
 
    bool scanAutoStartEnabled() const;
    void enableScanAutoStart(bool enable);
 
    Frequency rxFrequency() const;
    void setRXFrequency(const Frequency &f);
    Frequency txFrequency() const;
    void setTXFrequency(const Frequency &f);
 
    bool hasDTMFPTTSettingsIndex() const;
    unsigned int dtmfPTTSettingsIndex() const;
    void setDTMFPTTSettingsIndex(unsigned int idx);
    void clearDTMFPTTSettingsIndex();
 
 
    Channel::Power power() const;
    void setPower(Channel::Power power);
 
    Admit admit() const;
    void setAdmit(Admit admit);
 
    Signaling::Code rxTone() const;
    void setRXTone(Signaling::Code code);
    Signaling::Code txTone() const;
    void setTXTone(Signaling::Code code);
 
    DMRChannel::TimeSlot timeSlot() const;
    void setTimeSlot(DMRChannel::TimeSlot ts);
 
    unsigned int colorCode() const;
    void setColorCode(unsigned int cc);
 
    bool groupListMatchesContact() const;
    bool groupListAllMatch() const;
    unsigned int groupListIndex() const;
    void setGroupListIndex(unsigned int idx);
    void setGroupListAllMatch();
    void setGroupListMatchesContact();
 
    bool hasTXContact() const;
    unsigned int txContactIndex() const;
    void setTXContactIndex(unsigned int idx);
    void clearTXContactIndex();
 
    bool hasEmergencySystemIndex() const;
    unsigned int emergencySystemIndex() const;
    void setEmergencySystemIndex(unsigned int idx);
    void clearEmergencySystemIndex();
 
    bool hasEncryptionKeyIndex() const;
    unsigned int encryptionKeyIndex() const;
    void setEncryptionKeyIndex(unsigned int idx);
    void clearEncryptionKeyIndex();
 
    Channel *toChannel(Context &ctx, const ErrorStack &err=ErrorStack());
    bool linkChannel(Channel *ch, Context &ctx, const ErrorStack &err=ErrorStack());
    bool encode(Channel *ch, Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength()                            { return 16; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int name()                                  { return 0x0000; }
      static constexpr unsigned int bandwidth()                             { return 0x0020; }
      static constexpr unsigned int scanList()                              { return 0x0021; }
      static constexpr unsigned int channelType()                           { return 0x0022; }
      static constexpr unsigned int talkaround()                            { return 0x0023; }
      static constexpr unsigned int rxOnly()                                { return 0x0024; }
      static constexpr unsigned int scanAutoStart()                         { return 0x0026; }
      static constexpr unsigned int rxFrequency()                           { return 0x0027; }
      static constexpr unsigned int txFrequency()                           { return 0x002b; }
      static constexpr unsigned int dtmfPTTSettingsIndex()                  { return 0x002f; }
      static constexpr unsigned int power()                                 { return 0x0030; }
      static constexpr unsigned int admid()                                 { return 0x0031; }
      static constexpr unsigned int rxToneMode()                            { return 0x0034; }
      static constexpr unsigned int rxCTCSS()                               { return 0x0035; }
      static constexpr unsigned int rxDCS()                                 { return 0x0036; }
      static constexpr unsigned int txToneMode()                            { return 0x0037; }
      static constexpr unsigned int txCTCSS()                               { return 0x0038; }
      static constexpr unsigned int txDCS()                                 { return 0x0039; }
      static constexpr unsigned int timeslot()                              { return 0x003c; }
      static constexpr unsigned int colorcode()                             { return 0x003d; }
      static constexpr unsigned int groupListIndex()                        { return 0x003e; }
      static constexpr unsigned int contactIndex()                          { return 0x0040; }
      static constexpr unsigned int emergencySystemIndex()                  { return 0x0042; }
      static constexpr unsigned int encryptionKeyIndex()                    { return 0x0044; }
    };
  };
 
 
  class ChannelBankElement: public Element
  {
  protected:
    ChannelBankElement(uint8_t *ptr, size_t size);
 
  public:
    ChannelBankElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x11802; }
 
    bool createChannels(Context &ctx, const ErrorStack &err);
    bool linkChannels(Context &ctx, const ErrorStack &err);
    bool encode(Context &ctx, const ErrorStack &err);
 
  public:
    struct Limit {
      static constexpr unsigned int channelCount()                          { return 1024; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int channelCount()                          { return 0x0000; }
      static constexpr unsigned int channels()                              { return 0x0002; }
      static constexpr unsigned int betweenChannels()                       { return ChannelElement::size(); }
    };
  };
 
 
  class ContactElement: public Element
  {
  protected:
    ContactElement(uint8_t *ptr, size_t size);
 
  public:
    ContactElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x025; }
 
    QString name() const;
    void setName(const QString &name);
 
    DMRContact::Type type() const;
    void setType(DMRContact::Type type);
 
    unsigned int id() const;
    void setID(unsigned int id);
 
    DMRContact *toContact(Context &ctx, const ErrorStack &err=ErrorStack());
    bool encode(const DMRContact *contact, Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength()                            { return 16; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int name()                                  { return 0x0000; }
      static constexpr unsigned int type()                                  { return 0x0020; }
      static constexpr unsigned int id()                                    { return 0x0021; }
    };
  };
 
 
  class ContactBankElement: public Element
  {
  protected:
    ContactBankElement(uint8_t *ptr, size_t size);
 
  public:
    ContactBankElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x9c02; }
 
    bool createContacts(Context &ctx, const ErrorStack &err);
    bool encode(Context &ctx, const ErrorStack &err);
 
  public:
    struct Limit {
      static constexpr unsigned int contactCount()                          { return 1024; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int contactCount()                          { return 0x0000; }
      static constexpr unsigned int contacts()                              { return 0x0802; }
      static constexpr unsigned int betweenContacts()                       { return ContactElement::size(); }
    };
  };
 
 
  class GroupListElement: public Element
  {
  protected:
    GroupListElement(uint8_t *ptr, size_t size);
 
  public:
    GroupListElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x0053; }
 
    QString name() const;
    void setName(const QString &name);
 
    unsigned int members() const;
    bool hasMember(unsigned int i) const;
    unsigned int memberIndex(unsigned int i) const;
 
    RXGroupList *toGroupList(Context &ctx, const ErrorStack &err=ErrorStack());
    bool linkGroupList(RXGroupList *lst, Context &ctx, const ErrorStack &err=ErrorStack());
    bool encode(RXGroupList *lst, Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength()                          { return 8; }
      static constexpr unsigned int memberCount()                         { return 33; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int name()                                  { return 0x0000; }
      static constexpr unsigned int memberCount()                           { return 0x0010; }
      static constexpr unsigned int members()                               { return 0x0011; }
      static constexpr unsigned int betweenMembers()                        { return 0x0002; }
    };
  };
 
 
  class GroupListBankElement: public Element
  {
  protected:
    GroupListBankElement(uint8_t *ptr, size_t size);
 
  public:
    GroupListBankElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x510f; }
 
    bool createGroupLists(Context &ctx, const ErrorStack &err);
    bool linkGroupLists(Context &ctx, const ErrorStack &err);
    bool encode(Context &ctx, const ErrorStack &err);
 
  public:
    struct Limit {
      static constexpr unsigned int memberCount()                         { return 250; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int memberCount()                           { return 0x0000; }
      static constexpr unsigned int members()                               { return 0x0001; }
      static constexpr unsigned int betweenMembers()                        { return GroupListElement::size(); }
    };
  };
 
 
  class ScanListElement: public Element
  {
  public:
    enum class ChannelMode {
      None=0, Fixed=1, Selected=2
    };
 
  protected:
    ScanListElement(uint8_t *ptr, size_t size);
 
  public:
    ScanListElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x005f; }
 
    QString name() const;
    void setName(const QString &name);
 
    ChannelMode primaryChannelMode() const;
    void setPrimaryChannelMode(ChannelMode mode);
    bool hasPrimaryZoneIndex() const;
    unsigned int primaryZoneIndex() const;
    void setPrimaryZoneIndex(unsigned int idx);
    void clearPrimaryZoneIndex();
    bool hasPrimaryChannelIndex() const;
    unsigned int primaryChannelIndex() const;
    void setPrimaryChannelIndex(unsigned int idx);
    void clearPrimaryChannelIndex();
 
    ChannelMode secondaryChannelMode() const;
    void setSecondaryChannelMode(ChannelMode mode);
    bool hasSecondaryZoneIndex() const;
    unsigned int secondaryZoneIndex() const;
    void setSecondaryZoneIndex(unsigned int idx);
    void clearSecondaryZoneIndex();
    bool hasSecondaryChannelIndex() const;
    unsigned int secondaryChannelIndex() const;
    void setSecondaryChannelIndex(unsigned int idx);
    void clearSecondaryChannelIndex();
 
    ChannelMode revertChannelMode() const;
    void setRevertChannelMode(ChannelMode mode);
    bool hasRevertZoneIndex() const;
    unsigned int revertZoneIndex() const;
    void setRevertZoneIndex(unsigned int idx);
    void clearRevertZoneIndex();
    bool hasRevertChannelIndex() const;
    unsigned int revertChannelIndex() const;
    void setRevertChannelIndex(unsigned int idx);
    void clearRevertChannelIndex();
 
    Interval rxHoldTime() const;
    void setRXHoldTime(const Interval &interval);
    Interval txHoldTime() const;
    void setTXHoldTime(const Interval &interval);
 
    ScanList *toScanList(Context &ctx, const ErrorStack &err=ErrorStack());
    bool linkScanList(ScanList *lst, Context&ctx, const ErrorStack &err=ErrorStack());
    bool encode(ScanList *lst, Context&ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength()                          { return 8; }
      static constexpr unsigned int memberCount()                         { return 32; }
      static TimeRange holdTime() {
        return TimeRange{Interval::fromSeconds(0), Interval::fromSeconds(10)};
      }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int name()                                  { return 0x0000; }
      static constexpr unsigned int memberCount()                           { return 0x0010; }
      static constexpr unsigned int members()                               { return 0x0011; }
      static constexpr unsigned int betweenMembers()                        { return 0x0002; }
      static constexpr unsigned int priChannel1Mode()                       { return 0x0051; }
      static constexpr unsigned int priChannel2Mode()                       { return 0x0052; }
      static constexpr unsigned int priChannel1Zone()                       { return 0x0053; }
      static constexpr unsigned int priChannel2Zone()                       { return 0x0054; }
      static constexpr unsigned int priChannel1Channel()                    { return 0x0055; }
      static constexpr unsigned int priChannel2Channel()                    { return 0x0057; }
      static constexpr unsigned int txChannelMode()                         { return 0x0059; }
      static constexpr unsigned int txChannelZone()                         { return 0x005a; }
      static constexpr unsigned int txChannelChannel()                      { return 0x005b; }
      static constexpr unsigned int holdTime()                              { return 0x005d; }
      static constexpr unsigned int txHoldTime()                            { return 0x005e; }
    };
  };
 
 
  class ScanListBankElement: public Element
  {
  protected:
    ScanListBankElement(uint8_t *ptr, size_t size);
 
  public:
    ScanListBankElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x601; }
 
    bool createScanLists(Context &ctx, const ErrorStack &err);
    bool linkScanLists(Context &ctx, const ErrorStack &err);
    bool encode(Context &ctx, const ErrorStack &err);
 
  public:
    struct Limit {
      static constexpr unsigned int memberCount()                           { return 16; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int memberCount()                           { return 0x0000; }
      static constexpr unsigned int members()                               { return 0x0011; }
      static constexpr unsigned int betweenMembers()                        { return ScanListElement::size(); }
    };
  };
 
 
  class DMRSettingsElement: public Element
  {
  protected:
    DMRSettingsElement(uint8_t *ptr, size_t size);
 
  public:
    DMRSettingsElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x000e; }
 
    Interval callHangTime() const;
    void setCallHangTime(const Interval &intv);
 
    Interval activeWaitTime() const;
    void setActiveWaitTime(const Interval &interval);
    unsigned int activeRetries() const;
    void setActiveRetries(unsigned int count);
 
    unsigned int txPreambles() const;
    void setTXPreambles(unsigned int count);
 
    bool decodeDisableRadioEnabled() const;
    void enableDecodeDisableRadio(bool enable);
    bool decodeRadioCheckEnabled() const;
    void enableDecodeRadioCheck(bool enable);
    bool decodeEnableRadioEnabled() const;
    void enableDecodeEnableRadio(bool enable);
 
    bool updateConfig(Context &ctx, const ErrorStack &err=ErrorStack());
    bool encode(Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr TimeRange callHangTime() { return TimeRange{
          Interval::fromSeconds(1), Interval::fromSeconds(90)
        }; }
      static constexpr TimeRange activeWaitTime() { return TimeRange{
          Interval::fromMilliseconds(120), Interval::fromMilliseconds(600)
        }; }
      static constexpr IntRange activeRetires() { return IntRange{ 1, 10}; }
      static constexpr IntRange txPreambles() { return IntRange{ 0, 63}; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int callHangTime()                          { return 0x0000; }
      static constexpr unsigned int activeWaitTime()                        { return 0x0001; }
      static constexpr unsigned int activeRetries()                         { return 0x0002; }
      static constexpr unsigned int txPreambles()                           { return 0x0003; }
      static constexpr unsigned int decodeDisableRadio()                    { return 0x0004; }
      static constexpr unsigned int decodeCheckRadio()                      { return 0x0005; }
      static constexpr unsigned int decodeEnableRadio()                     { return 0x0006; }
    };
  };
 
 
  class EncryptionKeyElement: public Element
  {
  protected:
    EncryptionKeyElement(uint8_t *ptr, size_t size);
 
  public:
    EncryptionKeyElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x005; }
 
    void clear();
    bool isValid() const;
 
    unsigned int keySize() const;
    void setKeySize(unsigned int size);
 
    BasicEncryptionKey *createEncryptionKey(const ErrorStack &err=ErrorStack()) const;
    bool encodeEncryptionKey(BasicEncryptionKey *key, const ErrorStack &err=ErrorStack());
 
  protected:
    struct Offset {
      static constexpr unsigned int size()        { return 0x0000; }
      static constexpr unsigned int key()         { return 0x0001; }
    };
  };
 
 
  class EncryptionKeyBankElement: public Element
  {
  protected:
    EncryptionKeyBankElement(uint8_t *ptr, size_t size);
 
  public:
    EncryptionKeyBankElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x0050; }
 
    bool createEncryptionKeys(Context &ctx, const ErrorStack &err=ErrorStack());
    bool encodeEncryptionKeys(Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int keys()        { return 16; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int keys()        { return 0x0000; }
      static constexpr unsigned int betweenKeys() { return EncryptionKeyElement::size(); }
    };
  };
 
 
  class MessageElement: public Element
  {
  protected:
    MessageElement(uint8_t *ptr, size_t size);
 
  public:
    MessageElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x051; }
 
    QString text() const;
    void setText(const QString &message);
 
    bool encode(SMSTemplate *message, const ErrorStack &err=ErrorStack());
    SMSTemplate *decode(const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int messageLength()  { return 40; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int size()        { return 0x0000; }
      static constexpr unsigned int text()        { return 0x0001; }
    };
  };
 
 
  class MessageBankElement: public Element
  {
  protected:
    MessageBankElement(uint8_t *ptr, size_t size);
 
  public:
    MessageBankElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x511; }
 
    unsigned int memberCount() const;
    void setMemberCount(unsigned int count);
 
    MessageElement message(unsigned int i);
 
    bool decode(SMSExtension *ext, const ErrorStack &err=ErrorStack());
    bool encode(const SMSExtension *ext, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int memberCount()                           { return 16; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int memberCount()                           { return 0x0000; }
      static constexpr unsigned int members()                               { return 0x0001; }
      static constexpr unsigned int betweenMembers()                        { return MessageElement::size(); }
    };
  };
 
 
  class DTMFSystemElement: public Element
  {
  protected:
    DTMFSystemElement(uint8_t *ptr, size_t size);
 
  public:
    DTMFSystemElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x005; }
 
  public:
    struct Limit {
      static constexpr Interval preambleDuration() { return Interval::fromMilliseconds(1000); }
      static constexpr TimeRange toneDuration() { return TimeRange{
          Interval::fromMilliseconds(30), Interval::fromMilliseconds(1900)
        }; }
      static constexpr TimeRange pauseDuration() { return TimeRange{
          Interval::fromMilliseconds(30), Interval::fromMilliseconds(1900)
        }; }
      static constexpr TimeRange deadTime() { return TimeRange{
          Interval::fromMilliseconds(200), Interval::fromSeconds(33)
        }; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int sidetone()                              { return 0x0000; }
      static constexpr unsigned int preambleDuration()                      { return 0x0001; }
      static constexpr unsigned int toneDuration()                          { return 0x0002; }
      static constexpr unsigned int pauseDuration()                         { return 0x0003; }
      static constexpr unsigned int deadTime()                              { return 0x0004; }
    };
  };
 
 
  class DTMFSystemBankElement: public Element
  {
  protected:
    DTMFSystemBankElement(uint8_t *ptr, size_t size);
 
  public:
    DTMFSystemBankElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x0014; }
 
  public:
    struct Limit {
      static constexpr unsigned int memberCount()                           { return 4; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int members()                               { return 0x0000; }
      static constexpr unsigned int betweenMembers()                        { return DTMFSystemElement::size(); }
    };
  };
 
 
  class DTMFNumberElement: public Element
  {
  protected:
    DTMFNumberElement(uint8_t *ptr, size_t size);
 
  public:
    DTMFNumberElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x000a; }
 
  public:
    struct Limit {
      static constexpr unsigned int digits() { return 16; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int count()                                 { return 0x0000; }
      static constexpr unsigned int digits()                                { return 0x0001; }
    };
  };
 
 
  class DTMFNumberBankElement: public Element
  {
  protected:
    DTMFNumberBankElement(uint8_t *ptr, size_t size);
 
  public:
    DTMFNumberBankElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x0090; }
 
  public:
    struct Limit {
      static constexpr unsigned int memberCount()                           { return 16; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int members()                               { return 0x0000; }
      static constexpr unsigned int betweenMembers()                        { return DTMFNumberElement::size(); }
    };
  };
 
 
  class DTMFPTTSettingElement: public Element
  {
  protected:
    DTMFPTTSettingElement(uint8_t *ptr, size_t size);
 
  public:
    DTMFPTTSettingElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x0005; }
 
  protected:
    struct Offset {
      static constexpr unsigned int systemIndex()                           { return 0x0000; }
      static constexpr unsigned int pttIDType()                             { return 0x0001; }
      static constexpr unsigned int pttIDMode()                             { return 0x0002; }
      static constexpr unsigned int connectIDIndex()                        { return 0x0003; }
      static constexpr unsigned int disconnectIDIndex()                     { return 0x0004; }
    };
  };
 
 
  class DTMFPTTSettingBankElement: public Element
  {
  protected:
    DTMFPTTSettingBankElement(uint8_t *ptr, size_t size);
 
  public:
    DTMFPTTSettingBankElement(uint8_t *ptr);
 
    static constexpr unsigned int size() { return 0x00a0; }
 
  public:
    struct Limit {
      static constexpr unsigned int memberCount()                           { return 32; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int members()                               { return 0x0000; }
      static constexpr unsigned int betweenMembers()                        { return DTMFPTTSettingElement::size(); }
    };
  };
 
public:
  explicit GD73Codeplug(QObject *parent = nullptr);
 
  Config *preprocess(Config *config, const ErrorStack &err=ErrorStack()) const;
  bool postprocess(Config *config, const ErrorStack &err=ErrorStack()) const;
 
  bool index(Config *config, Context &ctx, const ErrorStack &err=ErrorStack()) const;
  bool decode(Config *config, const ErrorStack &err=ErrorStack());
  bool encode(Config *config, const Flags &flags=Flags(), const ErrorStack &err=ErrorStack());
 
protected:
  virtual bool decodeTimestamp(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool encodeTimestamp(Context &ctx, const ErrorStack &err=ErrorStack());
 
  virtual bool createMessages(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool encodeMessages(Context &ctx, const ErrorStack &err=ErrorStack());
 
  virtual bool decodeSettings(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool encodeSettings(Context &ctx, const ErrorStack &err=ErrorStack());
 
  virtual bool createContacts(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool encodeContacts(Context &ctx, const ErrorStack &err=ErrorStack());
 
  virtual bool createDTMFContacts(Context &ctx, const ErrorStack &err=ErrorStack());
 
  virtual bool createGroupLists(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool linkGroupLists(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool encodeGroupLists(Context &ctx, const ErrorStack &err=ErrorStack());
 
  virtual bool createEncryptionKeys(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool encodeEncryptionKeys(Context &ctx, const ErrorStack &err=ErrorStack());
 
  virtual bool createChannels(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool linkChannels(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool encodeChannels(Context &ctx, const ErrorStack &err=ErrorStack());
 
  virtual bool createZones(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool linkZones(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool encodeZones(Context &ctx, const ErrorStack &err=ErrorStack());
 
  virtual bool createScanLists(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool linkScanLists(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool encodeScanLists(Context &ctx, const ErrorStack &err=ErrorStack());
 
protected:
  struct Offset {
    static constexpr unsigned int timestamp()                               { return 0x00000; }
    static constexpr unsigned int settings()                                { return 0x00061; }
    static constexpr unsigned int zones()                                   { return 0x0010b; }
    static constexpr unsigned int channels()                                { return 0x00d4c; }
    static constexpr unsigned int contacts()                                { return 0x125ff; }
    static constexpr unsigned int groupLists()                              { return 0x1c201; }
    static constexpr unsigned int scanLists()                               { return 0x21310; }
    static constexpr unsigned int dmrSettings()                             { return 0x21911; }
    static constexpr unsigned int encryptionKeys()                          { return 0x2191f; }
    static constexpr unsigned int messages()                                { return 0x2196f; }
    static constexpr unsigned int dtmfSystems()                             { return 0x21e80; }
    static constexpr unsigned int dtmfNumbers()                             { return 0x21e94; }
    static constexpr unsigned int dtmfPTTSettings()                         { return 0x21f24; }
  };
};
 
 
#endif // GD73CODEPLUG_HH