uv390_codeplug.hh

#ifndef UV390_CODEPLUG_HH
#define UV390_CODEPLUG_HH
 
#include "dm1701_codeplug.hh"

class UV390Codeplug : public TyTCodeplug
{
  Q_OBJECT
 
public:
  class ChannelElement: public TyTCodeplug::ChannelElement
  {
  protected:
    ChannelElement(uint8_t *ptr, size_t size);
 
  public:
    explicit ChannelElement(uint8_t *ptr);

    void clear() override;
 
    bool talkaround() const override;
    void enableTalkaround(bool enable) override;

    virtual bool privacySwitch() const;
    virtual void enablePrivacySwitch(bool enable);

    void setPrivacyType(PrivacyType type) override;

    virtual TyTChannelExtension::InCallCriterion inCallCriteria() const;
    virtual void setInCallCriteria(TyTChannelExtension::InCallCriterion crit);

    virtual TyTChannelExtension::KillTone turnOffFreq() const;
    virtual void setTurnOffFreq(TyTChannelExtension::KillTone freq);

    virtual Level squelch() const;
    virtual void setSquelch(Level value);

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

    virtual bool allowInterrupt() const;
    virtual void enableAllowInterrupt(bool enable);

    virtual bool dualCapacityDirectMode() const;
    virtual void enableDualCapacityDirectMode(bool enable);

    virtual bool dcdmLeader() const;
    virtual void enableDCDMLeader(bool enable);

    virtual Channel *toChannelObj(const ErrorStack &err=ErrorStack()) const override;
    virtual void fromChannelObj(const Channel *c, Context &ctx) override;
 
  protected:
    struct Offset: public TyTCodeplug::ChannelElement::Offset {
      static constexpr Bit privacySwitch()          { return {0x0005, 2}; }
      static constexpr Bit inCallCriteria()         { return {0x0005, 4}; }
      static constexpr Bit turnOffFreq()            { return {0x0005, 6}; }
      static constexpr unsigned int squelch()       { return 0x000f; }
      static constexpr Bit power()                  { return {0x001e, 0}; }
      static constexpr Bit allowInterrupt()         { return {0x001f, 2}; }
      static constexpr Bit dualCapacityDirectMode() { return {0x001f, 3}; }
      static constexpr Bit dcdmLeader()             { return {0x001f, 4}; }
    };
  };

  class VFOChannelElement: public ChannelElement
  {
  protected:
    VFOChannelElement(uint8_t *ptr, size_t size);
 
  public:
    VFOChannelElement(uint8_t *ptr);
    virtual ~VFOChannelElement();
 
    QString name() const;
    void setName(const QString &txt);

    virtual unsigned stepSize() const;
    virtual void setStepSize(unsigned ss_hz);
  };

  typedef DM1701Codeplug::ZoneExtElement ZoneExtElement;

  class GeneralSettingsElement: public DM1701Codeplug::GeneralSettingsElement
  {
  protected:
    GeneralSettingsElement(uint8_t *ptr, size_t size);
 
  public:
    GeneralSettingsElement(uint8_t *ptr);
 
    void clear();

    enum TransmitMode {
      LAST_CALL_CH = 0,
      LAST_CALL_AND_HAND_CH = 1,
      DESIGNED_CH = 2,
      DESIGNED_AND_HAND_CH = 3,
    };

    virtual TransmitMode transmitMode() const;
    virtual void setTransmitMode(TransmitMode mode);

    virtual bool channelVoiceAnnounce() const;
    virtual void enableChannelVoiceAnnounce(bool enable);

    virtual bool keypadTones() const;
    virtual void enableKeypadTones(bool enable);

    virtual bool publicZone() const;
    virtual void enablePublicZone(bool enable);

    virtual uint32_t additionalDMRId(unsigned n) const;
    virtual void setAdditionalDMRId(unsigned n, uint32_t id);

    virtual Level micLevel() const;
    virtual void setMICLevel(Level val);

    virtual bool editRadioID() const;
    virtual void enableEditRadioID(bool enable);

    virtual bool fromConfig(const Config *config);
    virtual bool updateConfig(Config *config);
 
  public:
    struct Limit: DM1701Codeplug::GeneralSettingsElement::Limit {
      static constexpr Range<unsigned int> micGain() { return {0,6}; }
    };
 
  protected:
    struct Offset: DM1701Codeplug::GeneralSettingsElement::Offset {
      static constexpr Bit micGain() { return {0x00a0, 3}; }
    };
  };

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

    virtual unsigned zoneIndex() const;
    virtual void setZoneIndex(unsigned idx);
    virtual unsigned channelIndexA() const;
    virtual void setChannelIndexA(unsigned idx);
    virtual unsigned channelIndexB() const;
    virtual void setChannelIndexB(unsigned idx);
  };

  class MenuSettingsElement: public TyTCodeplug::MenuSettingsElement
  {
  protected:
    MenuSettingsElement(uint8_t *ptr, size_t size);
 
  public:
    explicit MenuSettingsElement(uint8_t *ptr);
 
    void clear();

    virtual bool gpsSettings() const;
    virtual void enableGPSSettings(bool enable);
    virtual bool recording() const;
    virtual void enableRecording(bool enable);

    virtual bool groupCallMatch() const;
    virtual void enableGroupCallMatch(bool enable);
    virtual bool privateCallMatch() const;
    virtual void enablePrivateCallMatch(bool enable);
    virtual bool menuHangtimeItem() const;
    virtual void enableMenuHangtimeItem(bool enable);
    virtual bool txMode() const;
    virtual void enableTXMode(bool enable);
    virtual bool zoneSettings() const;
    virtual void enableZoneSettings(bool enable);
    virtual bool newZone() const;
    virtual void enableNewZone(bool enable);

    virtual bool editZone() const;
    virtual void enableEditZone(bool enable);
    virtual bool newScanList() const;
    virtual void enableNewScanList(bool enable);
  };
 
 
public:
  explicit UV390Codeplug(QObject *parent = nullptr);
  virtual ~UV390Codeplug();
 
  void clear();
 
public:
  void clearTimestamp();
  bool encodeTimestamp();
 
  void clearGeneralSettings();
  bool encodeGeneralSettings(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack());
  bool decodeGeneralSettings(Context &ctx, const ErrorStack &err=ErrorStack());
 
  void clearChannels();
  bool encodeChannels( const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack());
  bool createChannels(Context &ctx, const ErrorStack &err=ErrorStack());
  bool linkChannels(Context &ctx, const ErrorStack &err=ErrorStack());
 
  void clearContacts();
  bool encodeContacts(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack());
  bool createContacts(Context &ctx, const ErrorStack &err=ErrorStack());
 
  void clearZones();
  bool encodeZones(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack());
  bool createZones(Context &ctx, const ErrorStack &err=ErrorStack());
  bool linkZones(Context &ctx, const ErrorStack &err=ErrorStack());
 
  void clearGroupLists();
  bool encodeGroupLists(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack());
  bool createGroupLists(Context &ctx, const ErrorStack &err=ErrorStack());
  bool linkGroupLists(Context &ctx, const ErrorStack &err=ErrorStack());
 
  void clearScanLists();
  bool encodeScanLists(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack());
  bool createScanLists(Context &ctx, const ErrorStack &err=ErrorStack());
  bool linkScanLists(Context &ctx, const ErrorStack &err=ErrorStack());
 
  void clearPositioningSystems();
  bool encodePositioningSystems(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack());
  bool createPositioningSystems(Context &ctx, const ErrorStack &err=ErrorStack());
  bool linkPositioningSystems(Context &ctx, const ErrorStack &err=ErrorStack());
 
  void clearButtonSettings();
  bool encodeButtonSettings(const Flags &flags, Context &ctx, const ErrorStack &err=ErrorStack());
  bool decodeButtonSetttings(Context &ctx, const ErrorStack &err=ErrorStack());
 
  void clearPrivacyKeys();
  bool encodePrivacyKeys(const Flags &flags, Context &ctx, const ErrorStack &err);
  bool decodePrivacyKeys(Context &ctx, const ErrorStack &err);
 
  void clearTextMessages();
  bool encodeTextMessages(Context &ctx, const Flags &flags, const ErrorStack &err);
  bool decodeTextMessages(Context &ctx, const ErrorStack &err);

  virtual void clearBootSettings();
  void clearMenuSettings();
  void clearEmergencySystems();
  virtual void clearVFOSettings();
 
public:
  struct Limit: public Element::Limit {
    static constexpr unsigned int channels() { return 3000; }
  };
 
protected:
  struct Offset {
    static constexpr unsigned int messages() { return 0x002180; }
    static constexpr unsigned int channels() { return 0x110000; }
    static constexpr unsigned int betweenChannels() { return ChannelElement::size(); }
  };
};
 
#endif // UV390CODEPLUG_HH