channel.hh

#ifndef CHANNEL_HH
#define CHANNEL_HH
 
#include <QObject>
#include <QAbstractTableModel>
 
#include "configobject.hh"
#include "configreference.hh"
#include "signaling.hh"
#include "interval.hh"
#include "level.hh"
 
#include "channel_extension.hh"
#include "opengd77_extension.hh"
#include "tyt_extensions.hh"
#include "opengd77_extension.hh"
#include "anytone_extension.hh"
#include "commercial_extension.hh"
 
class Config;
class RXGroupList;
class DMRContact;
class M17Contact;
class ScanList;
class FMAPRSSystem;
class PositionReportingSystem;
class RoamingZone;
class DMRRadioID;
 

class Channel: public ConfigObject
{
  Q_OBJECT

  Q_PROPERTY(Frequency rxFrequency READ rxFrequency WRITE setRXFrequency)
  Q_PROPERTY(Frequency txFrequency READ txFrequency WRITE setTXFrequency)
  Q_PROPERTY(Power power READ power WRITE setPower SCRIPTABLE false)
  Q_PROPERTY(Interval timeout READ timeout WRITE setTimeout)
  Q_PROPERTY(bool rxOnly READ rxOnly WRITE setRXOnly)
  Q_PROPERTY(ScanListReference* scanListRef READ scanListRef)
  Q_PROPERTY(Level vox READ vox WRITE setVOX)
  Q_PROPERTY(OpenGD77ChannelExtension* openGD77 READ openGD77ChannelExtension WRITE setOpenGD77ChannelExtension)
  Q_PROPERTY(TyTChannelExtension* tyt READ tytChannelExtension WRITE setTyTChannelExtension)

  Q_CLASSINFO("IdPrefix", "ch")
 
public:
  enum class Power {
    Max,  
    High, 
    Mid,  
    Low,  
    Min   
  };
  Q_ENUM(Power)
 
  enum class OffsetShift {
      None,     
      Positive,  
      Negative  
  };
  Q_ENUM(OffsetShift)
 
  
  enum class Type {
    None=0, DMR=1, M17=2, FM=4, AM=8, Analog=FM|AM, Digital=DMR|M17, All=Analog|Digital
  };
  Q_ENUM(Type);
  Q_DECLARE_FLAGS(Types, Type);
  Q_FLAGS(Types);
 
protected:
  explicit Channel(QObject *parent=nullptr);
  Channel(const Channel &other, QObject *parent=nullptr);
 
public:
  bool copy(const ConfigItem &other);
  void clear();

  Frequency rxFrequency() const;
  bool setRXFrequency(Frequency freq);
  Frequency txFrequency() const;
  bool setTXFrequency(Frequency freq);
  FrequencyOffset offsetFrequency() const;
  OffsetShift offsetShift() const;

  bool defaultPower() const;
  Power power() const;
  void setPower(Power power);
  void setDefaultPower();

  bool defaultTimeout() const;
  bool timeoutDisabled() const;
  Interval timeout() const;
  bool setTimeout(const Interval &dur);
  void disableTimeout();
  void setDefaultTimeout();

  bool rxOnly() const;
  bool setRXOnly(bool enable);

  bool voxDisabled() const;
  bool defaultVOX() const;
  Level vox() const;
  void setVOX(Level level);
  void setVOXDefault();
  void disableVOX();

  const ScanListReference *scanListRef() const;
  ScanListReference *scanListRef();
  ScanList *scanList() const;
  bool setScanList(ScanList *list);

  OpenGD77ChannelExtension *openGD77ChannelExtension() const;
  void setOpenGD77ChannelExtension(OpenGD77ChannelExtension *ext);

  TyTChannelExtension *tytChannelExtension() const;
  void setTyTChannelExtension(TyTChannelExtension *ext);
 
public:
  bool parse(const YAML::Node &node, Context &ctx, const ErrorStack &err=ErrorStack());
  bool link(const YAML::Node &node, const Context &ctx, const ErrorStack &err=ErrorStack());
 
protected:
  bool populate(YAML::Node &node, const Context &context, const ErrorStack &err=ErrorStack());
 
protected slots:
  void onReferenceModified();
 
protected:
  Frequency _rxFreq;
  Frequency _txFreq;
  bool _defaultPower;
  Power _power;
  Interval _txTimeOut;
  bool _rxOnly;
  Level _vox;
  ScanListReference _scanlist;
  OpenGD77ChannelExtension *_openGD77ChannelExtension;
  TyTChannelExtension *_tytChannelExtension;
};
 
 

class AnalogChannel: public Channel
{
  Q_OBJECT

  Q_PROPERTY(Level squelch READ squelch WRITE setSquelch FINAL)
 
protected:
  explicit AnalogChannel(QObject *parent=nullptr);
 
public:
  AnalogChannel(const AnalogChannel &other, QObject *parent=nullptr);
 

  bool defaultSquelch() const;
  bool squelchDisabled() const;
  Level squelch() const;
  bool setSquelch(Level squelch);
  void disableSquelch();
  void setSquelchDefault();
 
 
protected:
  Level _squelch;
};
 
 

class FMChannel: public AnalogChannel
{
  Q_OBJECT

  Q_PROPERTY(Admit admit READ admit WRITE setAdmit)
  Q_PROPERTY(SelectiveCall rxTone READ rxTone WRITE setRXTone)
  Q_PROPERTY(SelectiveCall txTone READ txTone WRITE setTXTone)
  Q_PROPERTY(Bandwidth bandwidth READ bandwidth WRITE setBandwidth)
  Q_PROPERTY(FMAPRSSystemReference* aprs READ aprsRef)

  Q_PROPERTY(FMChannelExtension *extended READ extended);
  Q_PROPERTY(AnytoneFMChannelExtension* anytone READ anytoneChannelExtension WRITE setAnytoneChannelExtension)
 
 
public:
  enum class Admit {
    Always,  
    Free,    
    Tone     
  };
  Q_ENUM(Admit)
 
  
  enum class Bandwidth {
    Narrow,  
    Wide     
  };
  Q_ENUM(Bandwidth)
 
public:
  Q_INVOKABLE explicit FMChannel(QObject *parent=nullptr);
 
  bool copy(const ConfigItem &other);
  ConfigItem *clone() const;
  void clear();

  Admit admit() const;
  void setAdmit(Admit admit);

  SelectiveCall rxTone() const;
  bool setRXTone(SelectiveCall code);
  SelectiveCall txTone() const;
  bool setTXTone(SelectiveCall code);

  Bandwidth bandwidth() const;
  bool setBandwidth(Bandwidth bw);

  const FMAPRSSystemReference *aprsRef() const;
  FMAPRSSystemReference *aprsRef();
  FMAPRSSystem *aprs() const;
  void setAPRS(FMAPRSSystem *sys);

  FMChannelExtension *extended() const;

  AnytoneFMChannelExtension *anytoneChannelExtension() const;
  void setAnytoneChannelExtension(AnytoneFMChannelExtension *ext);
 
public:
  YAML::Node serialize(const Context &context, const ErrorStack &err=ErrorStack());
  bool parse(const YAML::Node &node, Context &ctx, const ErrorStack &err=ErrorStack());
 
protected:
    Admit _admit;
  SelectiveCall _rxTone;
  SelectiveCall _txTone;
  Bandwidth _bw;
  FMAPRSSystemReference _aprsSystem;
  FMChannelExtension *_extended;
  AnytoneFMChannelExtension *_anytoneExtension;
};
 
 

class AMChannel: public AnalogChannel
{
  Q_OBJECT
 
public:
  Q_INVOKABLE explicit AMChannel(QObject *parent=nullptr);
 
  bool copy(const ConfigItem &other) override;
  ConfigItem *clone() const override;
  void clear() override;
 
public:
  YAML::Node serialize(const Context &context, const ErrorStack &err=ErrorStack()) override;
  bool parse(const YAML::Node &node, Context &ctx, const ErrorStack &err=ErrorStack()) override;
};
 
 

class DigitalChannel: public Channel
{
  Q_OBJECT
 
protected:
  explicit DigitalChannel(QObject *parent=nullptr);
 
public:
  DigitalChannel(const DigitalChannel &other, QObject *parent=nullptr);
};
 
 

class DMRChannel: public DigitalChannel
{
  Q_OBJECT

  Q_PROPERTY(Admit admit READ admit WRITE setAdmit)
  Q_PROPERTY(unsigned colorCode READ colorCode WRITE setColorCode)
  Q_PROPERTY(TimeSlot timeSlot READ timeSlot WRITE setTimeSlot)
  Q_PROPERTY(DMRRadioIDReference* radioId READ radioIdRef)
  Q_PROPERTY(GroupListReference* groupList READ groupListRef)
  Q_PROPERTY(DMRContactReference* contact READ contactRef)
  Q_PROPERTY(PositioningSystemReference* aprs READ aprsRef)
  Q_PROPERTY(RoamingZoneReference* roaming READ roamingRef)

  Q_PROPERTY(DMRChannelExtension* extended READ extended)
  Q_PROPERTY(CommercialChannelExtension* commercial READ commercialExtension WRITE setCommercialExtension)
  Q_PROPERTY(AnytoneDMRChannelExtension* anytone READ anytoneChannelExtension WRITE setAnytoneChannelExtension)
 
public:
  enum class Admit {
    Always,      
    Free,        
    ColorCode    
  };
  Q_ENUM(Admit)
 
  
  enum class TimeSlot {
    TS1, 
    TS2  
  };
  Q_ENUM(TimeSlot)
 
public:
  Q_INVOKABLE explicit DMRChannel(QObject *parent=nullptr);
 
  ConfigItem *clone() const;
  void clear();

    Admit admit() const;
    void setAdmit(Admit admit);

    unsigned colorCode() const;
    bool setColorCode(unsigned cc);

  TimeSlot timeSlot() const;
    bool setTimeSlot(TimeSlot ts);

  const GroupListReference *groupListRef() const;
  GroupListReference *groupListRef();
  RXGroupList *groupList() const;
  bool setGroupList(RXGroupList *rxg);

  const DMRContactReference *contactRef() const;
  DMRContactReference *contactRef();
  DMRContact *contact() const;
  bool setContact(DMRContact *c);

  const PositioningSystemReference *aprsRef() const;
  PositioningSystemReference *aprsRef();
  PositionReportingSystem *aprs() const;
  bool setAPRS(PositionReportingSystem *sys);

  const RoamingZoneReference *roamingRef() const;
  RoamingZoneReference *roamingRef();
  RoamingZone *roaming() const;
  bool setRoaming(RoamingZone *zone);

  const DMRRadioIDReference *radioIdRef() const;
  DMRRadioIDReference *radioIdRef();
  DMRRadioID *radioId() const;
  bool setRadioId(DMRRadioID *id);

  DMRChannelExtension *extended() const;

  CommercialChannelExtension *commercialExtension() const;
  void setCommercialExtension(CommercialChannelExtension *ext);

  AnytoneDMRChannelExtension *anytoneChannelExtension() const;
  void setAnytoneChannelExtension(AnytoneDMRChannelExtension *ext);
 
public:
  YAML::Node serialize(const Context &context, const ErrorStack &err=ErrorStack());
 
protected:
  Admit _admit;
  unsigned _colorCode;
  TimeSlot _timeSlot;
  GroupListReference _rxGroup;
  DMRContactReference _txContact;
  PositioningSystemReference _posSystem;
  RoamingZoneReference _roaming;
  DMRRadioIDReference _radioId;

  DMRChannelExtension *_extended;
  CommercialChannelExtension *_commercialExtension;
  AnytoneDMRChannelExtension *_anytoneExtension;
};
 

class M17Channel: public DigitalChannel
{
  Q_OBJECT

  Q_PROPERTY(unsigned accessNumber READ accessNumber WRITE setAccessNumber)
  Q_PROPERTY(M17ContactReference* contact READ contactRef WRITE setContactRef)
  Q_PROPERTY(Mode mode READ mode WRITE setMode)
  Q_PROPERTY(EncryptionMode encryptionMode READ encryptionMode WRITE setEncryptionMode)
  Q_PROPERTY(bool aprs READ aprsEnabled WRITE enableAPRS)
 
public:
  enum class Mode {
    Voice, Data, VoiceAndData
  };
  Q_ENUM(Mode)
 
  
  enum class EncryptionMode {
    None, AES256, Scrambled
  };
  Q_ENUM(EncryptionMode)
 
public:
  M17Channel(QObject *parent=nullptr);
  M17Channel(const M17Channel &other, QObject *parent=nullptr);
 
  ConfigItem *clone() const;
  void clear();

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

  unsigned int accessNumber() const;
  void setAccessNumber(unsigned int can);

  const M17ContactReference *contactRef() const;
  M17ContactReference *contactRef();
  void setContactRef(M17ContactReference *ref);
  M17Contact *contact() const;
  bool setContact(M17Contact *c);

  bool aprsEnabled() const;
  void enableAPRS(bool enabled);

  EncryptionMode encryptionMode() const;
  void setEncryptionMode(EncryptionMode mode);
 
public:
  YAML::Node serialize(const Context &context, const ErrorStack &err=ErrorStack());
 
protected:
  Mode _mode;
  unsigned int _accessNumber;
  M17ContactReference _txContact;
  bool _gpsEnabled;
  EncryptionMode _encryptionMode;
};
 

class SelectedChannel: public Channel
{
  Q_OBJECT
 
protected:
  explicit SelectedChannel();
 
public:
  virtual ~SelectedChannel();
 
  bool copy(const ConfigItem &other);
  ConfigItem *clone() const;

  static SelectedChannel *get();
 
protected:
  static SelectedChannel *_instance;
};
 
 

class ChannelList: public ConfigObjectList
{
  Q_OBJECT
 
public:
    explicit ChannelList(QObject *parent=nullptr);
 
  int add(ConfigObject *obj, int row=-1, bool unique=true);

  Channel *channel(int idx) const;
  DMRChannel *findDMRChannel(Frequency rx, Frequency tx, DMRChannel::TimeSlot ts, unsigned cc) const;
  FMChannel *findFMChannelByTxFreq(Frequency freq) const;
 
public:
  ConfigItem *allocateChild(const YAML::Node &node, ConfigItem::Context &ctx, const ErrorStack &err=ErrorStack());
};
 
 
Q_DECLARE_OPERATORS_FOR_FLAGS(Channel::Types)
 
#endif // CHANNEL_HH