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 GPSSystem;
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:
    ContactElement(uint8_t *ptr, size_t size);
 
  public:
    ContactElement(uint8_t *ptr);
    virtual ~ContactElement();
 
    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;
  };
 
  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 unsigned txPreambleDuration() const;
    virtual void setTXPreambleDuration(unsigned ms);
    virtual unsigned groupCallHangTime() const;
    virtual void setGroupCallHangTime(unsigned ms);
    virtual unsigned privateCallHangTime() const;
    virtual void setPrivateCallHangTime(unsigned ms);
    virtual unsigned voxSesitivity() const;
    virtual void setVOXSesitivity(unsigned ms);
    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);
  };
 
  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 unsigned repeatInterval() const;
    virtual void setRepeatInterval(unsigned 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(GPSSystem *sys, Context &ctx);
    virtual GPSSystem *toGPSSystemObj();
    virtual bool linkGPSSystemObj(GPSSystem *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;
 
  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(Config *config, const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodeGeneralSettings(Config *config, const ErrorStack &err=ErrorStack()) = 0;
 
  virtual void clearContacts() = 0;
  virtual bool encodeContacts(Config *config, const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createContacts(Config *config, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
 
  virtual void clearGroupLists() = 0;
  virtual bool encodeGroupLists(Config *config, const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createGroupLists(Config *config, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool linkGroupLists(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
 
  virtual void clearChannels() = 0;
  virtual bool encodeChannels(Config *config, const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createChannels(Config *config, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool linkChannels(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
 
  virtual void clearZones() = 0;
  virtual bool encodeZones(Config *config, const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createZones(Config *config, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool linkZones(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
 
  virtual void clearScanLists() = 0;
  virtual bool encodeScanLists(Config *config, const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createScanLists(Config *config, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool linkScanLists(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
 
  virtual void clearPositioningSystems() = 0;
  virtual bool encodePositioningSystems(Config *config, const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool createPositioningSystems(Config *config, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool linkPositioningSystems(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
 
  virtual void clearButtonSettings() = 0;
  virtual bool encodeButtonSettings(Config *config, const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodeButtonSetttings(Config *config, const ErrorStack &err=ErrorStack()) = 0;
 
  virtual void clearPrivacyKeys() = 0;
  virtual bool encodePrivacyKeys(Config *config, const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodePrivacyKeys(Config *config, 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