opengd77base_codeplug.hh

#ifndef OPENGD77BASE_CODEPLUG_HH
#define OPENGD77BASE_CODEPLUG_HH
 
#include "channel.hh"
#include "codeplug.hh"
#include "gpssystem.hh"
#include "contact.hh"
#include "zone.hh"
#include "satellitedatabase.hh"
#include "melody.hh"
 
#include <QGeoCoordinate>

class OpenGD77BaseCodeplug : public Codeplug
{
  Q_OBJECT
 
public:
  enum ImageType { EEPROM = 0, FLASH = 1 };
 
public:
  static uint32_t encodeAngle(double degee);
  static double decodeAngle(uint32_t code);

  static uint16_t encodeSelectiveCall(const SelectiveCall &call);
  static SelectiveCall decodeSelectiveCall(uint16_t code);
 
public:
  class ChannelElement: public Codeplug::Element
  {
  public:
    enum Mode {
      MODE_ANALOG = 0,   
      MODE_DIGITAL = 1   
    };

    enum class Alias {
      None = 0, APRS = 1, Text = 2, Both = 3
    };

    enum class SquelchMode {
      Global, Open, Normal, Closed
    };
 
  protected:
    ChannelElement(uint8_t *ptr, size_t size);
 
  public:
    explicit ChannelElement(uint8_t *ptr);
    virtual ~ChannelElement();

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

    virtual void clear();

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

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

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

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

    virtual Interval transmitTimeout() const;
    virtual void setTransmitTimeout(const Interval &interval);

    virtual bool fixedPositionEnabled() const;
    virtual QGeoCoordinate fixedPosition() const;
    virtual void setFixedPosition(const QGeoCoordinate &coordinate);
    virtual void enableFixedPosition(bool enable);

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

    virtual bool isSimplex() const;
    virtual void enableSimplex(bool enable);

    virtual bool powerSave() const;
    virtual void enablePowerSave(bool enable);

    virtual bool beep() const;
    virtual void enableBeep(bool enable);

    virtual bool hasDMRId() const;
    virtual unsigned int dmrId() const;
    virtual void setDMRId(unsigned int id);
    virtual void clearDMRId();

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

    virtual unsigned colorCode() const;
    virtual void setColorCode(unsigned cc);

    virtual bool hasAPRSIndex() const;
    virtual unsigned int aprsIndex() const;
    virtual void setAPRSIndex(unsigned int index);
    virtual void clearAPRSIndex();

    virtual bool hasTXContact() const;
    virtual unsigned int txContactIndex() const;
    virtual void setTXContactIndex(unsigned int index);
    virtual void clearTXContact();

    virtual OpenGD77ChannelExtension::TalkerAlias aliasTimeSlot1() const;
    virtual void setAliasTimeSlot1(OpenGD77ChannelExtension::TalkerAlias alias);
    virtual OpenGD77ChannelExtension::TalkerAlias aliasTimeSlot2() const;
    virtual void setAliasTimeSlot2(OpenGD77ChannelExtension::TalkerAlias alias);

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

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

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

    virtual bool skipScan() const;
    virtual void enableSkipScan(bool enable);
    virtual bool skipZoneScan() const;
    virtual void enableSkipZoneScan(bool enable);

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

    virtual SquelchMode squelchMode() const;
    virtual unsigned int squelchLevel() const;
    virtual void setSquelch(SquelchMode mode, unsigned int level);

    virtual Channel *decode(Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool link(Channel *c, Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool encode(const Channel *c, Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength() { return 16; }
    };
 
  protected:
    struct Offset: public Element::Offset {
      static constexpr unsigned int name() { return 0x0000; }
      static constexpr unsigned int rxFrequency() { return 0x0010; }
      static constexpr unsigned int txFrequency() { return 0x0014; }
      static constexpr unsigned int mode() { return 0x0018; }
      static constexpr unsigned int power() { return 0x0019; }
      static constexpr unsigned int latitude0() { return 0x001a; }
      static constexpr unsigned int txTimeout() { return 0x001b; }
      static constexpr unsigned int latitude1() { return 0x001c; }
      static constexpr unsigned int latitude2() { return 0x001d; }
      static constexpr unsigned int longitude0() { return 0x001e; }
      static constexpr unsigned int longitude1() { return 0x001f; }
      static constexpr unsigned int rxTone() { return 0x0020; }
      static constexpr unsigned int txTone() { return 0x0022; }
      static constexpr unsigned int longitude2() { return 0x0024; }
      static constexpr Bit simplex() { return {0x0026, 2}; }
      static constexpr Bit useFixedLocation() { return {0x0026, 3}; }
      static constexpr Bit disablePowerSave() { return {0x0026, 5}; }
      static constexpr Bit disableBeep() { return {0x0026, 6}; }
      static constexpr Bit overrideDMRID() { return {0x0026, 7}; }
      static constexpr unsigned int dmrId() { return 0x0027; }
      static constexpr unsigned int groupList() { return 0x002b; }
      static constexpr unsigned int colorCode() { return 0x002c; }
      static constexpr unsigned int aprsIndex() { return 0x002d; }
      static constexpr unsigned int txContact() { return 0x002e; }
      static constexpr Bit aliasTimeSlot2() { return { 0x030, 2}; }
      static constexpr Bit aliasTimeSlot1() { return { 0x030, 0}; }
      static constexpr Bit timeSlot() { return {0x0031, 6}; }
      static constexpr Bit bandwidth() { return {0x0033, 1}; }
      static constexpr Bit enableMonitor() { return {0x0033, 3}; }
      static constexpr Bit rxOnly() { return {0x0033, 2}; }
      static constexpr Bit skipScan() { return {0x0033, 4}; }
      static constexpr Bit skipZoneScan() { return {0x0033, 5}; }
      static constexpr Bit vox() { return {0x0033, 6}; }
      static constexpr unsigned int squelch() { return 0x0037; }
    };
  };
 

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

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

    void clear();

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

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

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

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

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

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

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

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

    virtual Frequency uhfMinFrequency() const;
    virtual void setUHFMinFrequency(const Frequency &f);
    virtual Frequency uhfMaxFrequency() const;
    virtual void setUHFMaxFrequency(const Frequency &f);

    virtual Frequency vhfMinFrequency() const;
    virtual void setVHFMinFrequency(const Frequency &f);
    virtual Frequency vhfMaxFrequency() const;
    virtual void setVHFMaxFrequency(const Frequency &f);

    virtual QString call() const;
    virtual void setCall(const QString &call);

    virtual unsigned int radioId() const;
    virtual void setRadioId(unsigned int id);

    virtual bool encode(const Context &ctx, const ErrorStack &err = ErrorStack());
    virtual bool decode(const Context &ctx, const ErrorStack &err = ErrorStack());
 
  public:
    struct Limit: public Element::Limit {
      static constexpr unsigned int callLength() { return 8; }
    };
 
  protected:
    struct Offset: public Element::Offset {
      static constexpr unsigned int uhfMinFrequency() { return 0x0000; }
      static constexpr unsigned int uhfMaxFrequency() { return 0x0002; }
      static constexpr unsigned int vhfMinFrequency() { return 0x0004; }
      static constexpr unsigned int vhfMaxFrequency() { return 0x0006; }
      static constexpr unsigned int call()            { return 0x0060; }
      static constexpr unsigned int dmrId()           { return 0x0068; }
    };
  };
 

  class APRSSettingsElement: public Element
  {
  public:
    enum class BaudRate {
      Baud300 = 1, Baud1200 = 0
    };

    enum class PositionPrecision {
      Max = 0,
      Mask1_8sec = 1,
      Mask3_6sec = 2,
      Mask18sec = 3,
      Mask36sec = 4,
      Mask3min = 5,
      Mask6min = 6,
      Mask30min = 7
    };
 
  public:
    explicit APRSSettingsElement(uint8_t *ptr);
 
  protected:
    APRSSettingsElement(uint8_t *ptr, size_t size);
 
  public:
    static constexpr unsigned int size() { return 0x40; }

    void clear();

    virtual bool isValid() const;

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

    virtual unsigned int sourceSSID() const;
    virtual void setSourceSSID(unsigned int ssid);

    virtual bool fixedPositionEnabled() const;
    virtual QGeoCoordinate fixedPosition() const;
    virtual void setFixedPosition(const QGeoCoordinate &coor);
    virtual void enableFixedPosition(bool enable);

    virtual PositionPrecision positionPrecision() const;
    virtual void setPositionPrecision(PositionPrecision prec);

    virtual bool hasVia1() const;
    virtual QString via1Call() const;
    virtual unsigned int via1SSID() const;
    virtual void setVia1(const QString &call, unsigned int ssid);
    virtual void clearVia1();

    virtual bool hasVia2() const;
    virtual QString via2Call() const;
    virtual unsigned int via2SSID() const;
    virtual void setVia2(const QString &call, unsigned int ssid);
    virtual void clearVia2();

    virtual FMAPRSSystem::Icon icon() const;
    virtual void setIcon(FMAPRSSystem::Icon icon);

    virtual QString comment() const;
    virtual void setComment(const QString &text);

    virtual BaudRate baudRate() const;
    virtual void setBaudRate(BaudRate rate);
 
    Frequency fmFrequency() const;
    void setFMFrequency(Frequency f);

    virtual bool encode(const FMAPRSSystem *system, const Context &ctx, const ErrorStack &err=ErrorStack());
    virtual FMAPRSSystem *decode(const Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool link(FMAPRSSystem *system, const Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit: public Element::Limit {
      static constexpr unsigned int nameLength() { return 8; }
      static constexpr unsigned int commentLength() { return 23; }
    };
 
  protected:
    struct Offset: public Element::Offset
    {
      static constexpr unsigned int name() { return 0x0000; }
      static constexpr unsigned int sourceSSID() { return 0x0008; }
      static constexpr unsigned int latitude() { return 0x0009; }
      static constexpr unsigned int longitude() { return 0x000c; }
      static constexpr unsigned int via1Call() { return 0x000f; }
      static constexpr unsigned int via1SSID() { return 0x0015; }
      static constexpr unsigned int via2Call() { return 0x0016; }
      static constexpr unsigned int via2SSID() { return 0x001c; }
      static constexpr unsigned int iconTable() { return 0x001d; }
      static constexpr unsigned int iconIndex() { return 0x001e; }
      static constexpr unsigned int comment() { return 0x001f; }
      static constexpr unsigned int fmFrequency() { return 0x0037; }
      static constexpr Bit positionPrecision() { return { 0x003d, 4}; }
      static constexpr Bit transmitQSY() { return { 0x003d, 2}; }
      static constexpr Bit useFixedPosition() { return { 0x003d, 1}; }
      static constexpr Bit baudRate() { return { 0x003d, 0}; }
      static constexpr unsigned int unknownBytes() { return 0x003e; }
    };
  };
 

  class APRSSettingsBankElement: public Element
  {
  public:
    explicit APRSSettingsBankElement(uint8_t *ptr);
 
  protected:
    APRSSettingsBankElement(uint8_t *ptr, size_t size);
 
  public:
    static constexpr unsigned int size() { return 0x40; }

    void clear();

    APRSSettingsElement system(unsigned int idx) const;

    virtual bool encode(Context &ctx, const ErrorStack &err=ErrorStack());
    virtual bool decode(Context &ctx, const ErrorStack &err=ErrorStack());
    virtual bool link(Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit: public Element::Limit {
      static constexpr unsigned int systems() { return 8; }
    };
 
  public:
    struct Offset: public Element::Offset {
      static constexpr unsigned int systems() { return 0x0000; }
      static constexpr unsigned int betweenSystems() { return APRSSettingsElement::size(); }
    };
  };
 

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

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

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

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

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

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

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

    DTMFContactElement contact(unsigned int n) const;

    virtual bool encode(Context &ctx, const ErrorStack &err=ErrorStack());
    virtual bool decode(Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit: public Element::Limit {
      static constexpr unsigned int contacts() { return 64; }
    };
 
  public:
    struct Offset: public Element::Offset {
      static constexpr unsigned int contacts() { return 0x0000; }
      static constexpr unsigned int betweenContacts() { return DTMFContactElement::size(); }
    };
  };
 

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

    void clear();

    virtual bool bootText() const;
    virtual void enableBootText(bool enable);

    virtual bool bootPasswordEnabled() const;
    virtual unsigned bootPassword() const;
    virtual void setBootPassword(unsigned passwd);
    virtual void clearBootPassword();

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

    virtual bool encode(const Context &ctx, const ErrorStack &err = ErrorStack());
    virtual bool decode(Context &ctx, const ErrorStack &err = ErrorStack());
 
  public:
    struct Limit: public Element::Limit {
      static constexpr unsigned int lineLength() { return 16; }
    };
 
  public:
    struct Offset: public Element::Offset {
      static constexpr unsigned int bootText() { return 0x0000; }
      static constexpr unsigned int bootPasswdEnable() { return 0x0001; }
      static constexpr unsigned int bootPasswd() { return 0x000c; }
      static constexpr unsigned int line1() { return 0x0028; }
      static constexpr unsigned int line2() { return 0x0038; }
    };
  };
 

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

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

    void clear();
    bool isValid() const;

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

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

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

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

    static constexpr unsigned int size() {
      return 0x0020 + Limit::zoneCount()*ZoneElement::size();
    }

    void clear();

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

    ZoneElement zone(unsigned int n);

    virtual bool encode(Context &ctx, const ErrorStack &err=ErrorStack());
    virtual bool decode(Context &ctx, const ErrorStack &err=ErrorStack());
    virtual bool link(Context &ctx, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit: public Element::Limit {
      static constexpr unsigned int zoneCount() { return 68; }
    };
 
  protected:
    struct Offset: public Element::Offset {
      static constexpr unsigned int bitmap() { return 0x0000; }
      static constexpr unsigned int zones()  { return 0x0020; }
      static constexpr unsigned int betweenZones() { return ZoneElement::size(); }
    };
  };
 

  class ContactElement: public Element
  {
  public:
    enum class TimeSlotOverride {
      None = 0x01,                  
      TS1  = 0x00,                  
      TS2  = 0x02                   
    };
 
  protected:
    ContactElement(uint8_t *ptr, unsigned size);
 
  public:
    explicit ContactElement(uint8_t *ptr);
    virtual ~ContactElement();

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

    void clear();

    bool isValid() const;

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

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

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

    virtual TimeSlotOverride timeSlotOverride() const;
    virtual void setTimeSlotOverride(TimeSlotOverride ts);

    virtual DMRContact *decode(Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool encode(const DMRContact *obj, 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 number() { return 0x0010; }
      static constexpr unsigned int type() { return 0x0014; }
      static constexpr unsigned int timeSlotOverride() { return 0x0017; }
    };
  };
 

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

    static constexpr unsigned int size() {
      return Limit::contactCount() * ContactElement::size();
    }

    void clear();

    ContactElement contact(unsigned int idx) const;

    virtual bool encode(Context &ctx, const ErrorStack &err = ErrorStack());
    virtual bool decode(Context &ctx, const ErrorStack &err = ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int contactCount() { return 1024; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int contacts() { return 0x0000; }
      static constexpr unsigned int betweenContacts() { return ContactElement::size(); }
      // @endcond
    };
  };
 

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

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

    void clear();

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

    virtual bool hasContactIndex(unsigned int i) const;
    virtual unsigned int contactIndex(unsigned int i) const;
    virtual void setContactIndex(unsigned int i, unsigned int contactIdx);
    virtual void clearContactIndex(unsigned int i);

    virtual bool encode(RXGroupList *lst, Context &ctx, const ErrorStack &err=ErrorStack());
    virtual RXGroupList *decode(Context &ctx, const ErrorStack &err=ErrorStack()) const;
    virtual bool link(RXGroupList *lst, Context &ctx, const ErrorStack &err=ErrorStack()) const;
 
  public:
    struct Limit {
      static constexpr unsigned int nameLength() { return 15; }
      static constexpr unsigned int contactCount() { return 32; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int name() { return 0x0000; }
      static constexpr unsigned int contacts() { return 0x0010; }
      static constexpr unsigned int betweenContacts() { return 0x0002; }
      // @endcond
    };
  };
 

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

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

    void clear();

    virtual bool hasGroupList(unsigned int i) const;
    virtual unsigned int groupListContactCount(unsigned int i) const;
    virtual void setGroupListContactCount(unsigned int i, unsigned int count);
    virtual GroupListElement groupList(unsigned int i) const;
    virtual void clearGroupList(unsigned int i);

    virtual bool encode(Context &ctx, const ErrorStack &err = ErrorStack());
    virtual bool decode(Context &ctx, const ErrorStack &err = ErrorStack());
    virtual bool link(Context &ctx, const ErrorStack &err = ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int groupListCount() { return 76; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int length() { return 0x0000; }
      static constexpr unsigned int groupLists() { return 0x0080; }
      static constexpr unsigned int betweenGroupLists() { return GroupListElement::size(); }
      // @endcond
    };
  };
 

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

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

    virtual void setName(const QString &name);

    virtual void setEpoch(const ::OrbitalElement::Epoch &epoch);
    virtual void setMeanMotion(double mm);
    virtual void setMeanMotionDerivative(double dmm);
    virtual void setInclination(double incl);
    virtual void setAscension(double asc);
    virtual void setEccentricity(double ecc);
    virtual void setPerigee(double arg);
    virtual void setMeanAnomaly(double ma);
    virtual void setRevolutionNumber(unsigned int num);

    void setFMDownlink(const Frequency &f);
    void setFMUplink(const Frequency &f);
    void setCTCSS(const SelectiveCall &call);
    void setAPRSDownlink(const Frequency &f);
    void setAPRSUplink(const Frequency &f);

    void setBeacon(const Frequency &f);

    void setAPRSPath(const QString &path);

    virtual bool encode(const Satellite &sat, const ErrorStack &err = ErrorStack());
 
  protected:
    void writeFixedPoint(const Offset::Bit &offset, double value, bool sign, unsigned int dec, unsigned int frac);
    void writeFractional(const Offset::Bit &offset, double value, bool sign, unsigned int frac);
    void writeInteger(const Offset::Bit &offset, int value, bool sign, unsigned dec);
    void writeDigit(const Offset::Bit &offset, uint8_t digit);
 
  public:
    struct Limit: public Element::Limit {
      static constexpr unsigned int nameLength() { return 8; }
      static constexpr unsigned int pathLength() { return 24; }
    };
 
  protected:
    struct Offset: public Element::Offset {
      static constexpr unsigned int name()         { return 0x0000; }
      static constexpr Bit epochYear()             { return {0x0008, 4}; }
      static constexpr Bit epochJulienDay()        { return {0x0009, 4}; }
      static constexpr Bit meanMotionDerivative()  { return {0x000f, 4}; }
      static constexpr Bit inclination()           { return {0x0014, 4}; }
      static constexpr Bit ascension()             { return {0x0018, 4}; }
      static constexpr Bit eccentricity()          { return {0x001c, 4}; }
      static constexpr Bit perigee()               { return {0x001f, 0}; }
      static constexpr Bit meanAnomaly()           { return {0x0023, 0}; }
      static constexpr Bit meanMotion()            { return {0x0027, 0}; }
      static constexpr Bit revolutionNumber()      { return {0x002d, 4}; }
      static constexpr unsigned int fmDownlink()   { return 0x0030; }
      static constexpr unsigned int fmUplink()     { return 0x0034; }
      static constexpr unsigned int ctcss()        { return 0x0038; }
      static constexpr unsigned int aprsDownlink() { return 0x003c; }
      static constexpr unsigned int aprsUplink()   { return 0x0040; }
      static constexpr unsigned int beacon()       { return 0x0044; }
      static constexpr unsigned int aprsPath()     { return 0x004c; }
    };
  };
 

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

    static constexpr unsigned int size()  { return 0x09e0; }
    static constexpr unsigned int magic() { return 0x0003; }
 
    void clear();

    SatelliteElement satellite(unsigned int idx);
    bool encode(SatelliteDatabase *db, const ErrorStack &err=ErrorStack());
 
  public:
    struct Limit {
      static constexpr unsigned int satellites() { return 25; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int blockId()           { return 0x0000; }
      static constexpr unsigned int segmentSize()       { return 0x0004; }
      static constexpr unsigned int satellites()        { return 0x0008; }
      static constexpr unsigned int betweenSatellites() { return SatelliteElement::size(); }
    };
  };
 
 
  class NoteElement: public Element
  {
  public:
    explicit NoteElement(uint8_t *ptr);

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

    bool isPause() const;
    double frequency() const;
    void setFrequency(double pitch);
    void setPause();

    unsigned int duration() const;
    void setDuration(unsigned int ms);
 
  protected:
    struct Offset: Element::Offset {
      static constexpr unsigned int pitch()    { return 0x0000; }
      static constexpr unsigned int duration() { return 0x0001; }
    };
 
    static constexpr double _lut[] = {
      0110.00, 0116.54, 0123.47,
      0130.81, 0138.59, 0146.83, 0155.56, 0164.81, 0174.61, 0185.00, 0196.00, 0207.65, 0220.00, 0233.08, 0246.94,
      0261.62, 0277.18, 0293.66, 0311.13, 0329.63, 0349.23, 0369.99, 0392.00, 0415.30, 0440.00, 0466.16, 0493.88,
      0523.25, 0554.37, 0587.33, 0622.25, 0659.25, 0698.46, 0739.99, 0783.99, 0830.61, 0880.00, 0932.33, 0987.77,
      1046.50, 1108.73, 1174.66, 1244.51, 1318.51, 1396.91
    };
  };

  class BootMelodyElement: public Element
  {
  public:
    BootMelodyElement(uint8_t *ptr);

    static constexpr unsigned int size() { return 0x0208; }
    static constexpr unsigned int magic() { return 0x0002; }
 
    void clear();

    virtual bool encode(Context &ctx, const Melody *melody, const ErrorStack &err=ErrorStack());
    virtual bool decode(Context &ctx, Melody *melody, const ErrorStack &err=ErrorStack()) const;
 
  public:
    struct Limit {
      static constexpr unsigned int notes() { return 256; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int blockId()           { return 0x0000; }
      static constexpr unsigned int segmentSize()       { return 0x0004; }
      static constexpr unsigned int notes()             { return 0x0008; }
      static constexpr unsigned int betweenNotes() { return NoteElement::size(); }
    };
  };
 

  class AdditionalSettingsElement: public Element
  {
  public:
    enum Settings {
      BootImage         = 1,
      BootMelody        = 2,
      SatelliteOrbitals = 3,
      LightTheme        = 4,
      DarkTheme         = 5
    };
 
  protected:
    AdditionalSettingsElement(uint8_t *ptr, size_t size);
 
  public:
    AdditionalSettingsElement(uint8_t *ptr);

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

    virtual QString magic() const;
    virtual unsigned int version() const;

    virtual bool hasSettings(Settings set) const;
    virtual SatelliteBankElement satellites() const;
    virtual BootMelodyElement bootMelody() const;
 
  public:
    struct Limit {
      static constexpr unsigned int magicStringLength() { return 8; }
    };
 
  protected:
    struct Offset {
      static constexpr unsigned int magicString()    { return 0x0000; }
      static constexpr unsigned int versionNumber()  { return 0x0008; }
      static constexpr unsigned int blocks()         { return 0x000c; }
      // @endcond
    };
  };
 
 
protected:
  explicit OpenGD77BaseCodeplug(QObject *parent = nullptr);
 
public:
  virtual void clear();
 
  bool index(Config *config, Context &ctx, const ErrorStack &err=ErrorStack()) const;
 
  bool decode(Config *config, const ErrorStack &err=ErrorStack());
  bool postprocess(Config *config, const ErrorStack &err=ErrorStack()) const;
 
  Config *preprocess(Config *config, const ErrorStack &err=ErrorStack()) const;
  bool encode(Config *config, const Flags &flags = Flags(), const ErrorStack &err=ErrorStack());
 
public:
  virtual bool decodeElements(Context &ctx, const ErrorStack &err=ErrorStack());
  virtual bool encodeElements(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack());

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

  virtual void clearDTMFSettings() = 0;
  virtual bool encodeDTMFSettings(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodeDTMFSettings(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

  virtual void clearAPRSSettings() = 0;
  virtual bool encodeAPRSSettings(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool decodeAPRSSettings(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool linkAPRSSettings(Context &ctx, const ErrorStack &err=ErrorStack()) = 0;

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

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

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

  virtual void clearVFOSettings() = 0;

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

  virtual void 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;
};
 
#endif // OPENGD77BASE_CODEPLUG_HH