tyt_codeplug.hh

#ifndef TYT_CODEPLUG_HH
#define TYT_CODEPLUG_HH
 
#include <QDateTime>
 
#include "codeplug.hh"
#include "signaling.hh"
#include "channel.hh"
#include "contact.hh"
#include "tyt_extensions.hh"
 
class DMRContact;
class Zone;
class RXGroupList;
class ScanList;
class DMRAPRSSystem;
class SMSExtension;
class SMSTemplate;

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

    enum Bandwidth {
      BW_12_5_KHZ = 0,              
      BW_20_KHZ   = 1,              
      BW_25_KHZ   = 2               
    };

    enum PrivacyType {
      PRIV_NONE = 0,                
      PRIV_BASIC = 1,               
      PRIV_ENHANCED = 2             
    };

    enum Admit {
      ADMIT_ALWAYS = 0,             
      ADMIT_CH_FREE = 1,            
      ADMIT_TONE = 2,               
      ADMIT_COLOR = 3,              
    };
 
  protected:
    ChannelElement(uint8_t *ptr, size_t size);
 
  public:
    ChannelElement(uint8_t *ptr);
    virtual ~ChannelElement();

    bool isValid() const;
    void clear();

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

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

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

    virtual bool autoScan() const;
    virtual void enableAutoScan(bool enable);

    virtual bool loneWorker() const;
    virtual void enableLoneWorker(bool enable);

    virtual bool talkaround() const;
    virtual void enableTalkaround(bool enable);

    virtual bool rxOnly() const;
    virtual void enableRXOnly(bool enable);

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

    virtual uint8_t colorCode() const;
    virtual void setColorCode(uint8_t ts);

    virtual uint8_t privacyIndex() const;
    virtual void setPrivacyIndex(uint8_t ts);
    virtual PrivacyType privacyType() const;
    virtual void setPrivacyType(PrivacyType type);

    virtual bool privateCallConfirm() const;
    virtual void enablePrivateCallConfirm(bool enable);

    virtual bool dataCallConfirm() const;
    virtual void enableDataCallConfirm(bool enable);

    virtual TyTChannelExtension::RefFrequency rxRefFrequency() const;
    virtual void setRXRefFrequency(TyTChannelExtension::RefFrequency ref);
    virtual TyTChannelExtension::RefFrequency txRefFrequency() const;
    virtual void setTXRefFrequency(TyTChannelExtension::RefFrequency ref);

    virtual bool emergencyAlarmACK() const;
    virtual void enableEmergencyAlarmACK(bool enable);

    virtual bool displayPTTId() const;
    virtual void enableDisplayPTTId(bool enable);

    virtual bool vox() const;
    virtual void enableVOX(bool enable);

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

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

    virtual bool txTimeOutDisabled() const;
    virtual Interval txTimeOut() const;
    virtual void setTXTimeOut(const Interval &tot);
    virtual void resetTXTimeOut();
    virtual uint8_t txTimeOutRekeyDelay() const;
    virtual void setTXTimeOutRekeyDelay(uint8_t delay);

    virtual uint8_t emergencySystemIndex() const;
    virtual void setEmergencySystemIndex(uint8_t idx);

    virtual uint8_t scanListIndex() const;
    virtual void setScanListIndex(uint8_t idx);

    virtual uint8_t groupListIndex() const;
    virtual void setGroupListIndex(uint8_t idx);

    virtual uint8_t positioningSystemIndex() const;
    virtual void setPositioningSystemIndex(uint8_t idx);

    virtual bool dtmfDecode(uint8_t idx) const;
    virtual void setDTMFDecode(uint8_t idx, bool enable);

    virtual Frequency rxFrequency() const;
    virtual void setRXFrequency(const Frequency &Hz);
    virtual Frequency txFrequency() const;
    virtual void setTXFrequency(const Frequency &Hz);

    virtual SelectiveCall rxSignaling() const;
    virtual void setRXSignaling(const SelectiveCall &code);
    virtual SelectiveCall txSignaling() const;
    virtual void setTXSignaling(const SelectiveCall &code);
    virtual uint8_t rxSignalingSystemIndex() const;
    virtual void setRXSignalingSystemIndex(uint8_t idx);
    virtual uint8_t txSignalingSystemIndex() const;
    virtual void setTXSignalingSystemIndex(uint8_t idx);

    virtual bool txGPSInfo() const;
    virtual void enableTXGPSInfo(bool enable);
    virtual bool rxGPSInfo() const;
    virtual void enableRXGPSInfo(bool enable);

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

    virtual Channel *toChannelObj(const ErrorStack &err=ErrorStack()) const;
    virtual bool linkChannelObj(Channel *c, Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual void fromChannelObj(const Channel *c, Context &ctx);
 
  public:
    struct Limit: public Element::Limit {
      static constexpr unsigned int nameLength() { return 16; }
    };
 
  protected:
    struct Offset: public Element::Offset {
      static constexpr Offset::Bit mode() { return {0x0000, 0}; }
      static constexpr Offset::Bit bandwidth() { return {0x0000, 2}; }
      static constexpr Offset::Bit autoscan() { return {0x0000, 4}; }
      static constexpr Offset::Bit loneworker() { return {0x0000, 8}; }
      static constexpr Offset::Bit talkaround() { return {0x0001, 0}; }
      static constexpr Offset::Bit rxonly() { return {0x0001, 1}; }
      static constexpr Offset::Bit timeslot() { return {0x0001, 2}; }
      static constexpr Offset::Bit colorcode() { return {0x0001, 4}; }
      static constexpr Offset::Bit privacyIndex() { return {0x0002, 0}; }
      static constexpr Offset::Bit privacyType() { return {0x0002, 4}; }
      static constexpr Offset::Bit privateCallConfirm() { return {0x0002, 6}; }
      static constexpr Offset::Bit dataCallConfirm() { return {0x0002, 7}; }
      static constexpr Offset::Bit rxRefFrequency() { return {0x0003, 0}; }
      static constexpr Offset::Bit emergencyAlarmACK() { return {0x0003, 3}; }
      static constexpr Offset::Bit displayPTTId() { return {0x0003, 7}; }
      static constexpr Offset::Bit txRefFrequency() { return {0x0004, 0}; }
      static constexpr Offset::Bit vox() { return {0x0004, 4}; }
      static constexpr Offset::Bit admitCriterion() { return {0x0004, 6}; }
      static constexpr unsigned int contactIndex() { return 0x0006; }
      static constexpr Offset::Bit txTimeOut() { return {0x0008, 0}; }
      static constexpr unsigned int txTimeOutRekeyDelay() { return 0x0009; }
      static constexpr unsigned int emergencySystemIndex() { return 0x000a; }
      static constexpr unsigned int scanListIndex() { return 0x000b; }
      static constexpr unsigned int groupListIndex() { return 0x000c; }
      static constexpr unsigned int positioningSystemIndex() { return 0x000d; }
      static constexpr unsigned int dtmfDecode() { return 0x000e; }
      static constexpr unsigned int rxFrequency() { return 0x0010; }
      static constexpr unsigned int txFrequency() { return 0x0014; }
      static constexpr unsigned int rxSignaling() { return 0x018; }
      static constexpr unsigned int txSignaling() { return 0x01a; }
      static constexpr unsigned int rxSignalingSystemIndex() { return 0x01c; }
      static constexpr unsigned int txSignalingSystemIndex() { return 0x01d; }
      static constexpr Offset::Bit txGPSInfo() { return {0x001f, 0}; }
      static constexpr Offset::Bit rxGPSInfo() { return {0x001f, 1}; }
      static constexpr unsigned int name() { return 0x0020; }
    };
  };

  class ContactElement: public Codeplug::Element
  {
  protected:
    enum class CallType {
      GroupCall=1, PrivateCall=2, AllCall=3
    };
 
  protected:
    ContactElement(uint8_t *ptr, size_t size);
 
  public:
    ContactElement(uint8_t *ptr);
    virtual ~ContactElement();

    static constexpr unsigned int size() { return 0x000024; }
    void clear();
    bool isValid() const;

    virtual uint32_t dmrId() const;
    virtual void setDMRId(uint32_t id);

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

    virtual bool ringTone() const;
    virtual void enableRingTone(bool enable);

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

    virtual bool fromContactObj(const DMRContact *contact);
    virtual DMRContact *toContactObj() const;
 
  public:
    struct Limit: Element::Limit {
      static constexpr unsigned int nameLength() { return 16; }
    };
 
  protected:
    struct Offset: Element::Offset {
      static constexpr unsigned int dmrId() { return 0x0000; }
      static constexpr Bit callType()       { return {0x0003, 0}; }
      static constexpr Bit ringTone()       { return {0x0003, 5}; }
      static constexpr unsigned int name()  { return 0x0004; }
    };
  };

  class ZoneElement: public Codeplug::Element
  {
  protected:
    ZoneElement(uint8_t *ptr, size_t size);
 
  public:
    ZoneElement(uint8_t *ptr);
    virtual ~ZoneElement();
 
    void clear();
    bool isValid() const;

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

    virtual uint16_t memberIndex(unsigned n) const;
    virtual void setMemberIndex(unsigned n, uint16_t idx);

    virtual bool fromZoneObj(const Zone *zone, Context &ctx);
    virtual Zone *toZoneObj() const;
    virtual bool linkZone(Zone *zone, Context &ctx) const;
  };

  class GroupListElement: public Codeplug::Element
  {
  protected:
    GroupListElement(uint8_t *ptr, size_t size);
 
  public:
    GroupListElement(uint8_t *ptr);
    virtual ~GroupListElement();
 
    void clear();
    bool isValid() const;

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

    virtual uint16_t memberIndex(unsigned n) const;
    virtual void setMemberIndex(unsigned n, uint16_t idx);

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

  class ScanListElement: public Codeplug::Element
  {
  protected:
    ScanListElement(uint8_t *ptr, size_t size);
 
  public:
    ScanListElement(uint8_t *ptr);
    virtual ~ScanListElement();
 
    bool isValid() const;
    void clear();

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

    virtual uint16_t priorityChannel1Index() const;
    virtual void setPriorityChannel1Index(uint16_t idx);

    virtual uint16_t priorityChannel2Index() const;
    virtual void setPriorityChannel2Index(uint16_t idx);

    virtual uint16_t txChannelIndex() const;
    virtual void setTXChannelIndex(uint16_t idx);

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

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

    virtual uint16_t memberIndex(unsigned n) const;
    virtual void setMemberIndex(unsigned n, uint16_t idx);

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

  class GeneralSettingsElement: public Codeplug::Element
  {
  protected:
    GeneralSettingsElement(uint8_t *ptr, size_t size);
 
  public:
    explicit GeneralSettingsElement(uint8_t *ptr);
    virtual ~GeneralSettingsElement();
 
    void clear();

    virtual QString introLine1() const;
    virtual void setIntroLine1(const QString line);
    virtual QString introLine2() const;
    virtual void setIntroLine2(const QString line);

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

    virtual bool allLEDsDisabled() const;
    virtual void disableAllLEDs(bool disable);

    virtual bool savePreamble() const;
    virtual void setSavePreamble(bool enable);
    virtual bool saveModeRX() const;
    virtual void setSaveModeRX(bool enable);
    virtual bool allTonesDisabled() const;
    virtual void disableAllTones(bool disable);
    virtual bool chFreeIndicationTone() const;
    virtual void setChFreeIndicationTone(bool enable);
    virtual bool passwdAndLock() const;
    virtual void enablePasswdAndLock(bool enable);
    virtual bool talkPermitToneDigital() const;
    virtual void enableTalkPermitToneDigital(bool enable);
    virtual bool talkPermitToneAnalog() const;
    virtual void enableTalkPermitToneAnalog(bool enable);

    virtual bool introPicture() const;
    virtual void enableIntroPicture(bool enable);

    virtual uint32_t dmrId() const;
    virtual void setDMRId(uint32_t id);

    virtual Interval txPreambleDuration () const;
    virtual void setTXPreambleDuration(const Interval &ms);
    virtual Interval groupCallHangTime() const;
    virtual void setGroupCallHangTime(const Interval &ms);
    virtual Interval privateCallHangTime() const;
    virtual void setPrivateCallHangTime(const Interval &ms);
    virtual Level voxSesitivity() const;
    virtual void setVOXSesitivity(Level level);
    virtual unsigned lowBatteryInterval() const;
    virtual void setLowBatteryInterval(unsigned sec);

    virtual bool callAlertToneIsContinuous() const;
    virtual unsigned callAlertToneDuration() const;
    virtual void setCallAlertToneDuration(unsigned sec);
    virtual void setCallAlertToneContinuous();

    virtual unsigned loneWorkerResponseTime() const;
    virtual void setLoneWorkerResponseTime(unsigned min);
    virtual unsigned loneWorkerReminderTime() const;
    virtual void setLoneWorkerReminderTime(unsigned min);
    virtual unsigned scanDigitalHangTime() const;
    virtual void setScanDigitalHangTime(unsigned ms);
    virtual unsigned scanAnalogHangTime() const;
    virtual void setScanAnalogHangTime(unsigned ms);

    virtual bool backlightIsAlways() const;
    virtual unsigned backlightTime() const;
    virtual void setBacklightTime(unsigned sec);
    virtual void backlightTimeSetAlways();

    virtual bool keypadLockIsManual() const;
    virtual unsigned keypadLockTime() const;
    virtual void setKeypadLockTime(unsigned sec);
    virtual void keypadLockTimeSetManual();

    virtual uint32_t powerOnPassword() const;
    virtual void setPowerOnPassword(uint32_t passwd);

    virtual bool radioProgPasswordEnabled() const;
    virtual uint32_t radioProgPassword() const;
    virtual void setRadioProgPassword(uint32_t passwd);
    virtual void radioProgPasswordDisable();

    virtual bool pcProgPasswordEnabled() const;
    virtual QString pcProgPassword() const;
    virtual void setPCProgPassword(const QString &pass);
    virtual void pcProgPasswordDisable();

    virtual QString radioName() const;
    virtual void setRadioName(const QString &name);

    virtual bool fromConfig(const Config *config);
    virtual bool updateConfig(Config *config);
 
  public:
    struct Limit: Element::Limit {
      // Valid VOX sensitivity range.
      static constexpr Range<unsigned int> vox() { return {1,10}; }
    };
  };

  class TimestampElement: public Codeplug::Element
  {
  protected:
    TimestampElement(uint8_t *ptr, size_t size);
 
  public:
    explicit TimestampElement(uint8_t *ptr);
    virtual ~TimestampElement();
 
    void clear();

    virtual QDateTime timestamp() const;
    virtual void setTimestamp(const QDateTime &ts);

    virtual QString cpsVersion() const;
  };

  class GPSSystemElement: public Codeplug::Element
  {
  protected:
    GPSSystemElement(uint8_t *ptr, size_t size);
 
  public:
    explicit GPSSystemElement(uint8_t *ptr);
    virtual ~GPSSystemElement();
 
    bool isValid() const;
    void clear();

    virtual bool revertChannelIsSelected() const;
    virtual uint16_t revertChannelIndex() const;
    virtual void setRevertChannelIndex(uint16_t idx);
    virtual void setRevertChannelSelected();

    virtual bool repeatIntervalDisabled() const;
    virtual Interval repeatInterval() const;
    virtual void setRepeatInterval(const Interval &sec);
    virtual void disableRepeatInterval();

    virtual bool destinationContactDisabled() const;
    virtual uint16_t destinationContactIndex() const;
    virtual void setDestinationContactIndex(uint16_t idx);
    virtual void disableDestinationContact();

    virtual bool fromGPSSystemObj(DMRAPRSSystem *sys, Context &ctx);
    virtual DMRAPRSSystem *toGPSSystemObj();
    virtual bool linkGPSSystemObj(DMRAPRSSystem *sys, Context &ctx);
  };

  class MenuSettingsElement: public Codeplug::Element
  {
  protected:
    MenuSettingsElement(uint8_t *ptr, size_t size);
 
  public:
    explicit MenuSettingsElement(uint8_t *ptr);
    virtual ~MenuSettingsElement();
 
    void clear();

    virtual bool menuHangtimeIsInfinite() const;
    virtual unsigned menuHangtime() const;
    virtual void setMenuHangtime(unsigned sec);
    virtual void infiniteMenuHangtime();

    virtual bool textMessage() const;
    virtual void enableTextMessage(bool enable);
    virtual bool callAlert() const;
    virtual void enableCallAlert(bool enable);
    virtual bool contactEditing() const;
    virtual void enableContactEditing(bool enable);
    virtual bool manualDial() const;
    virtual void enableManualDial(bool enable);
    virtual bool remoteRadioCheck() const;
    virtual void enableRemoteRadioCheck(bool enable);
    virtual bool remoteMonitor() const;
    virtual void enableRemoteMonitor(bool enable);
    virtual bool remoteRadioEnable() const;
    virtual void enableRemoteRadioEnable(bool enable);
    virtual bool remoteRadioDisable() const;
    virtual void enableRemoteRadioDisable(bool enable);

    virtual bool scan() const;
    virtual void enableScan(bool enable);
    virtual bool scanListEditing() const;
    virtual void enableScanListEditing(bool enable);
    virtual bool callLogMissed() const;
    virtual void enableCallLogMissed(bool enable);
    virtual bool callLogAnswered() const;
    virtual void enableCallLogAnswered(bool enable);
    virtual bool callLogOutgoing() const;
    virtual void enableCallLogOutgoing(bool enable);
    virtual bool talkaround() const;
    virtual void enableTalkaround(bool enable);
    virtual bool alertTone() const;
    virtual void enableAlertTone(bool enable);

    virtual bool power() const;
    virtual void enablePower(bool enable);
    virtual bool backlight() const;
    virtual void enableBacklight(bool enable);
    virtual bool bootScreen() const;
    virtual void enableBootScreen(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 vox() const;
    virtual void enableVOX(bool enable);

    virtual bool password() const;
    virtual void enablePassword(bool enable);
    virtual bool displayMode() const;
    virtual void enableDisplayMode(bool enable);
    virtual bool radioProgramming() const;
    virtual void enableRadioProgramming(bool enable);

    virtual bool fromConfig(const Config *config);
    virtual bool updateConfig(Config *config);
  };

  class ButtonSettingsElement: public Codeplug::Element
  {
  public:
    typedef enum TyTButtonSettings::ButtonAction ButtonAction;
 
  protected:
    ButtonSettingsElement(uint8_t *ptr, size_t size);
 
  public:
    explicit ButtonSettingsElement(uint8_t *ptr);
    virtual ~ButtonSettingsElement();
 
    void clear();

    virtual ButtonAction sideButton1Short() const;
    virtual void setSideButton1Short(ButtonAction action);
    virtual ButtonAction sideButton1Long() const;
    virtual void setSideButton1Long(ButtonAction action);

    virtual ButtonAction sideButton2Short() const;
    virtual void setSideButton2Short(ButtonAction action);
    virtual ButtonAction sideButton2Long() const;
    virtual void setSideButton2Long(ButtonAction action);

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

    virtual bool fromConfig(const Config *config);
    virtual bool updateConfig(Config *config);
  };

  class OneTouchSettingElement: public Codeplug::Element
  {
  public:
    enum Action {
      CALL    = 0b0000,                 
      MESSAGE = 0b0001,                 
      DTMF1   = 0b1000,                 
      DTMF2   = 0b1001,                 
      DTMF3   = 0b1010,                 
      DTMF4   = 0b1011                  
    };

    enum Type {
      Disabled = 0b00,                  
      Digital  = 0b01,                  
      Analog   = 0b10                   
    };
 
  protected:
    OneTouchSettingElement(uint8_t *ptr, size_t size);
 
  public:
    explicit OneTouchSettingElement(uint8_t *ptr);
    virtual ~OneTouchSettingElement();
 
    bool isValid() const;
    void clear();

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

    virtual Type actionType() const;
    virtual void setActionType(Type action);

    virtual uint8_t messageIndex() const;
    virtual void setMessageIndex(uint8_t idx);

    virtual uint16_t contactIndex() const;
    virtual void setContactIndex(uint16_t idx);
  };

  class EmergencySettingsElement: public Codeplug::Element
  {
  protected:
    EmergencySettingsElement(uint8_t *ptr, size_t size);
 
  public:
    explicit EmergencySettingsElement(uint8_t *ptr);
    virtual ~EmergencySettingsElement();
 
    virtual void clear();

    virtual bool emergencyRemoteMonitor() const;
    virtual void enableEmergencyRemoteMonitor(bool enable);
    virtual bool remoteMonitor() const;
    virtual void enableRemoteMonitor(bool enable);
    virtual bool radioDisable() const;
    virtual void enableRadioDisable(bool enable);

    virtual unsigned remoteMonitorDuration() const;
    virtual void setRemoteMonitorDuration(unsigned sec);

    virtual unsigned txTimeOut() const;
    virtual void setTXTimeOut(unsigned ms);

    virtual unsigned messageLimit() const;
    virtual void setMessageLimit(unsigned limit);
  };

  class EmergencySystemElement: public Codeplug::Element
  {
  public:
    enum AlarmType {
      DISABLED = 0,                     
      REGULAR = 1,                      
      SILENT = 2,                       
      SILENT_W_VOICE = 3                
    };

    enum AlarmMode {
      ALARM = 0,                        
      ALARM_W_CALL = 1,                 
      ALARM_W_VOICE = 2                 
    };
 
  protected:
    EmergencySystemElement(uint8_t *ptr, size_t size);
 
  public:
    explicit EmergencySystemElement(uint8_t *ptr);
    virtual ~EmergencySystemElement();
 
    bool isValid() const;
    void clear();

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

    virtual AlarmType alarmType() const;
    virtual void setAlarmType(AlarmType type);
    virtual AlarmMode alarmMode() const;
    virtual void setAlarmMode(AlarmMode mode);

    virtual unsigned impoliteRetries() const;
    virtual void setImpoliteRetries(unsigned num);

    virtual unsigned politeRetries() const;
    virtual void setPoliteRetries(unsigned num);

    virtual unsigned hotMICDuration() const;
    virtual void setHotMICDuration(unsigned sec);

    virtual bool revertChannelIsSelected() const;
    virtual uint16_t revertChannelIndex() const;
    virtual void setRevertChannelIndex(uint16_t idx);
    virtual void revertChannelSelected();
  };

  class EncryptionElement: public Codeplug::Element
  {
  protected:
    EncryptionElement(uint8_t *ptr, size_t size);
 
  public:
    explicit EncryptionElement(uint8_t *ptr);
    virtual ~EncryptionElement();
 
    void clear();

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

    virtual bool isEnhancedKeySet(unsigned n) const;
    virtual QByteArray enhancedKey(unsigned n) const;
    virtual void setEnhancedKey(unsigned n, const QByteArray &key);

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

    virtual bool fromCommercialExt(CommercialExtension *encr, Context &ctx);
    virtual bool updateCommercialExt(Context &ctx);
    virtual bool linkCommercialExt(CommercialExtension *ext, Context &ctx);
 
  public:
    struct Limit {
      static constexpr unsigned int basicKeys() { return 16; }
      static constexpr unsigned int advancedKeys() { return 8; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int advancedKeys() { return 0x0000; }
      static constexpr unsigned int betweenAdvancedKeys() { return 0x0010; }
      static constexpr unsigned int basicKeys() { return 0x0090; }
      static constexpr unsigned int betweenBasicKeys() { return 0x0002; }
    };
  };
 

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

    static constexpr unsigned int size() { return 0x00120; }
 
    void clear();
 
    bool isValid() const;

    virtual QString text() const;
    virtual void setText(const QString &text);

    virtual bool encode(SMSTemplate *sms, const ErrorStack &err=ErrorStack());
    virtual SMSTemplate *decode(const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int length() { return 144; }    
    };
  };

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

    static constexpr unsigned int size() { return MessageElement::size()*Limit::messages(); }
 
    void clear();

    virtual MessageElement message(unsigned int i) const;

    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 50; }
    };
  };
 
 
protected:
  explicit TyTCodeplug(QObject *parent = nullptr);
 
public:
  virtual ~TyTCodeplug();

  virtual void clear();
 
  bool index(Config *config, Context &ctx, const ErrorStack &err=ErrorStack()) const;
 
  Config *preprocess(Config *config, 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());
 
public:
  virtual bool decodeElements(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool encodeElements(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack());

  virtual void clearTimestamp() = 0;
  virtual bool encodeTimestamp() = 0;

  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 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 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 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 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 clearPositioningSystems() = 0;
  virtual bool encodePositioningSystems(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createPositioningSystems(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool linkPositioningSystems(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

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

  virtual void clearPrivacyKeys() = 0;
  virtual bool encodePrivacyKeys(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodePrivacyKeys(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearMenuSettings() = 0;

  virtual void clearTextMessages() = 0;
  virtual bool encodeTextMessages(Context &ctx, const Flags &flags, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodeTextMessages(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearEmergencySystems() = 0;
};
 
#endif // TYT_CODEPLUG_HH