channel.hh

#ifndef CHANNEL_HH
#define CHANNEL_HH
 
#include <QObject>
#include <QAbstractTableModel>
 
#include "configobject.hh"
#include "configreference.hh"
#include "signaling.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 ScanList;
class APRSSystem;
class PositioningSystem;
class RoamingZone;
class DMRRadioID;
 
 
class Channel: public ConfigObject
{
  Q_OBJECT
 
  Q_PROPERTY(Frequency rxFrequency READ rxFrequency WRITE setRXFrequency SCRIPTABLE false)
  Q_PROPERTY(Frequency txFrequency READ txFrequency WRITE setTXFrequency SCRIPTABLE false)
  Q_PROPERTY(Power power READ power WRITE setPower SCRIPTABLE false)
  Q_PROPERTY(unsigned timeout READ timeout WRITE setTimeout SCRIPTABLE false)
  Q_PROPERTY(bool rxOnly READ rxOnly WRITE setRXOnly)
  Q_PROPERTY(ScanListReference* scanListRef READ scanListRef)
  Q_PROPERTY(unsigned vox READ vox WRITE setVOX SCRIPTABLE false)
  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)
 
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);
 
  bool defaultPower() const;
  Power power() const;
  void setPower(Power power);
  void setDefaultPower();
 
  bool defaultTimeout() const;
  bool timeoutDisabled() const;
  unsigned timeout() const;
  bool setTimeout(unsigned dur);
  void disableTimeout();
  void setDefaultTimeout();
 
  bool rxOnly() const;
  bool setRXOnly(bool enable);
 
  bool voxDisabled() const;
  bool defaultVOX() const;
  unsigned vox() const;
  void setVOX(unsigned 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;
  unsigned _txTimeOut;
  bool _rxOnly;
  unsigned _vox;
  ScanListReference _scanlist;
  OpenGD77ChannelExtension *_openGD77ChannelExtension;
  TyTChannelExtension *_tytChannelExtension;
};
 
 
class AnalogChannel: public Channel
{
  Q_OBJECT
 
protected:
  explicit AnalogChannel(QObject *parent=nullptr);
 
public:
  AnalogChannel(const AnalogChannel &other, QObject *parent=nullptr);
};
 
 
class FMChannel: public AnalogChannel
{
  Q_OBJECT
 
  Q_PROPERTY(Admit admit READ admit WRITE setAdmit)
  Q_PROPERTY(unsigned squelch READ squelch WRITE setSquelch SCRIPTABLE false)
  Q_PROPERTY(Signaling::Code rxTone READ rxTone WRITE setRXTone SCRIPTABLE false)
  Q_PROPERTY(Signaling::Code txTone READ txTone WRITE setTXTone SCRIPTABLE false)
  Q_PROPERTY(Bandwidth bandwidth READ bandwidth WRITE setBandwidth)
  Q_PROPERTY(APRSSystemReference* aprs READ aprs WRITE setAPRS)
 
  
  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);
  FMChannel(const FMChannel &other, QObject *parent=nullptr);
 
  bool copy(const ConfigItem &other);
  ConfigItem *clone() const;
  void clear();
 
  Admit admit() const;
  void setAdmit(Admit admit);
 
  bool defaultSquelch() const;
  bool squelchDisabled() const;
    unsigned squelch() const;
    bool setSquelch(unsigned squelch);
  void disableSquelch();
  void setSquelchDefault();
 
  Signaling::Code rxTone() const;
  bool setRXTone(Signaling::Code code);
  Signaling::Code txTone() const;
  bool setTXTone(Signaling::Code code);
 
  Bandwidth bandwidth() const;
  bool setBandwidth(Bandwidth bw);
 
  const APRSSystemReference *aprs() const;
  APRSSystemReference *aprs();
  void setAPRS(APRSSystemReference *ref);
  APRSSystem *aprsSystem() const;
  void setAPRSSystem(APRSSystem *sys);
 
  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:
  bool populate(YAML::Node &node, const Context &context, const ErrorStack &err=ErrorStack());
 
protected:
    Admit _admit;
  unsigned _squelch;
  Signaling::Code _rxTone;
  Signaling::Code _txTone;
    Bandwidth _bw;
  APRSSystemReference _aprsSystem;
 
  AnytoneFMChannelExtension *_anytoneExtension;
};
 
 
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 radioId WRITE setRadioId)
  Q_PROPERTY(GroupListReference* groupList READ groupList WRITE setGroupList)
  Q_PROPERTY(DMRContactReference* contact READ contact WRITE setContact)
  Q_PROPERTY(PositioningSystemReference* aprs READ aprs WRITE setAPRS)
  Q_PROPERTY(RoamingZoneReference* roaming READ roaming WRITE setRoaming)
 
  
  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);
  DMRChannel(const DMRChannel &other, 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 *groupList() const;
  GroupListReference *groupList();
  void setGroupList(GroupListReference *ref);
  RXGroupList *groupListObj() const;
  bool setGroupListObj(RXGroupList *rxg);
 
  const DMRContactReference *contact() const;
  DMRContactReference *contact();
  void setContact(DMRContactReference *ref);
  DMRContact *txContactObj() const;
  bool setTXContactObj(DMRContact *c);
 
  const PositioningSystemReference *aprs() const;
  PositioningSystemReference *aprs();
  void setAPRS(PositioningSystemReference *ref);
  PositioningSystem *aprsObj() const;
  bool setAPRSObj(PositioningSystem *sys);
 
  const RoamingZoneReference *roaming() const;
  RoamingZoneReference *roaming();
  void setRoaming(RoamingZoneReference *ref);
  RoamingZone *roamingZone() const;
  bool setRoamingZone(RoamingZone *zone);
 
  const DMRRadioIDReference *radioId() const;
  DMRRadioIDReference *radioId();
  void setRadioId(DMRRadioIDReference *ref);
  DMRRadioID *radioIdObj() const;
  bool setRadioIdObj(DMRRadioID *id);
 
  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;
 
  CommercialChannelExtension *_commercialExtension;
  AnytoneDMRChannelExtension *_anytoneExtension;
};
 
 
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());
};
 
 
#endif // CHANNEL_HH