/// <summary>
        /// Add a new frequency.
        /// </summary>
        /// <param name="newFrequency">The frequency to be added.</param>
        public void AddFrequency(ISDBSatelliteFrequency newFrequency)
        {
            foreach (ISDBSatelliteFrequency oldFrequency in Frequencies)
            {
                if (oldFrequency.Frequency == newFrequency.Frequency)
                {
                    if (oldFrequency.Polarization == newFrequency.Polarization)
                    {
                        return;
                    }
                    else
                    {
                        if (oldFrequency.Polarization.PolarizationAbbreviation.CompareTo(newFrequency.Polarization.PolarizationAbbreviation) > 0)
                        {
                            Frequencies.Insert(Frequencies.IndexOf(oldFrequency), newFrequency);
                            return;
                        }
                    }
                }

                if (oldFrequency.Frequency > newFrequency.Frequency)
                {
                    Frequencies.Insert(Frequencies.IndexOf(oldFrequency), newFrequency);
                    return;
                }
            }

            Frequencies.Add(newFrequency);
        }
        /// <summary>
        /// Find a satelllite frequency.
        /// </summary>
        /// <param name="frequency">The frequency to be searched for.</param>
        /// <param name="polarization">The polariz\ation of the frequency to be searched for.</param>
        /// <returns>The tuning frequency or null if it cannot be located.</returns>
        public ISDBSatelliteFrequency FindFrequency(int frequency, SignalPolarization polarization)
        {
            foreach (TuningFrequency tuningFrequency in Frequencies)
            {
                if (tuningFrequency.Frequency == frequency)
                {
                    ISDBSatelliteFrequency satelliteFrequency = tuningFrequency as ISDBSatelliteFrequency;
                    if (satelliteFrequency != null && satelliteFrequency.Polarization.Polarization == polarization.Polarization)
                    {
                        return(satelliteFrequency);
                    }
                }
            }

            return(null);
        }
        /// <summary>
        /// Compare another satellite frequency with this one.
        /// </summary>
        /// <param name="compareFrequency">The tuning frequency to be compared to.</param>
        /// <returns>0 if the frequencies are equal, -1 if this instance is less, +1 otherwise.</returns>
        public override int CompareTo(object compareFrequency)
        {
            ISDBSatelliteFrequency satelliteFrequency = compareFrequency as ISDBSatelliteFrequency;

            if (satelliteFrequency == null)
            {
                throw (new ArgumentException("Object is not a ISDBSatelliteFrequency"));
            }

            if (satelliteFrequency.Frequency == Frequency)
            {
                return(polarization.ToString().CompareTo(satelliteFrequency.Polarization.ToString()));
            }

            return(Frequency.CompareTo(satelliteFrequency.Frequency));
        }
        /// <summary>
        /// Generate a copy of this frequency.
        /// </summary>
        /// <returns>A new instance with the same properties as the old instance.</returns>
        public override TuningFrequency Clone()
        {
            ISDBSatelliteFrequency newFrequency = new ISDBSatelliteFrequency();

            base.Clone(newFrequency);

            newFrequency.FEC          = fec;
            newFrequency.Polarization = polarization;
            newFrequency.SymbolRate   = symbolRate;

            if (satelliteDish != null)
            {
                newFrequency.SatelliteDish = (SatelliteDish)satelliteDish.Clone();
            }

            return(newFrequency);
        }
示例#5
0
 /// <summary>
 /// Initialize a new instance of the TuningSpec class for a ISDB satellite frequency.
 /// </summary>
 /// <param name="satellite">The satellite to tune to.</param>
 /// <param name="frequency">The frequency to tune to.</param>
 public TuningSpec(Satellite satellite, ISDBSatelliteFrequency frequency)
 {
     this.frequency = frequency;
     this.satellite = satellite;
     symbolRate = frequency.SymbolRate;
     fec = frequency.FEC;
     signalPolarization = frequency.Polarization;
 }
        internal void load(FileInfo fileInfo)
        {
            ISDBSatelliteFrequency satelliteFrequency = null;
            XmlReader reader = null;

            XmlReaderSettings settings = new XmlReaderSettings();

            settings.IgnoreWhitespace = true;

            try
            {
                reader = XmlReader.Create(fileInfo.FullName, settings);
            }
            catch (IOException)
            {
                Logger.Instance.Write("Failed to open " + fileInfo.Name);
                return;
            }

            try
            {
                while (!reader.EOF)
                {
                    reader.Read();
                    if (reader.IsStartElement())
                    {
                        switch (reader.Name)
                        {
                        case "Transponder":
                            if (satelliteFrequency != null)
                            {
                                AddFrequency(satelliteFrequency);
                            }

                            satelliteFrequency          = new ISDBSatelliteFrequency();
                            satelliteFrequency.Provider = this;

                            break;

                        default:
                            if (satelliteFrequency != null)
                            {
                                satelliteFrequency.load(reader);
                            }
                            break;
                        }
                    }
                }

                if (satelliteFrequency != null)
                {
                    AddFrequency(satelliteFrequency);
                }
            }
            catch (XmlException e)
            {
                Logger.Instance.Write("Failed to load file " + fileInfo.Name);
                Logger.Instance.Write("Data exception: " + e.Message);
            }
            catch (IOException e)
            {
                Logger.Instance.Write("Failed to load file " + fileInfo.Name);
                Logger.Instance.Write("I/O exception: " + e.Message);
            }

            if (reader != null)
            {
                reader.Close();
            }
        }
        /// <summary>
        /// Generate a copy of this frequency.
        /// </summary>
        /// <returns>A new instance with the same properties as the old instance.</returns>
        public override TuningFrequency Clone()
        {
            ISDBSatelliteFrequency newFrequency = new ISDBSatelliteFrequency();
            base.Clone(newFrequency);

            newFrequency.FEC = fec;
            newFrequency.Polarization = polarization;
            newFrequency.SymbolRate = symbolRate;

            if (satelliteDish != null)
                newFrequency.SatelliteDish = (SatelliteDish)satelliteDish.Clone();

            return (newFrequency);
        }
        internal void load(FileInfo fileInfo)
        {
            ISDBSatelliteFrequency satelliteFrequency = null;
            XmlReader reader = null;

            XmlReaderSettings settings = new XmlReaderSettings();
            settings.IgnoreWhitespace = true;

            try
            {
                reader = XmlReader.Create(fileInfo.FullName, settings);
            }
            catch (IOException)
            {
                Logger.Instance.Write("Failed to open " + fileInfo.Name);
                return;
            }

            try
            {
                while (!reader.EOF)
                {
                    reader.Read();
                    if (reader.IsStartElement())
                    {
                        switch (reader.Name)
                        {
                            case "Transponder":
                                if (satelliteFrequency != null)
                                    AddFrequency(satelliteFrequency);

                                satelliteFrequency = new ISDBSatelliteFrequency();
                                satelliteFrequency.Provider = this;

                                break;
                            default:
                                if (satelliteFrequency != null)
                                    satelliteFrequency.load(reader);
                                break;
                        }
                    }
                }

                if (satelliteFrequency != null)
                    AddFrequency(satelliteFrequency);
            }
            catch (XmlException e)
            {
                Logger.Instance.Write("Failed to load file " + fileInfo.Name);
                Logger.Instance.Write("Data exception: " + e.Message);
            }
            catch (IOException e)
            {
                Logger.Instance.Write("Failed to load file " + fileInfo.Name);
                Logger.Instance.Write("I/O exception: " + e.Message);
            }

            if (reader != null)
                reader.Close();
        }
        /// <summary>
        /// Add a new frequency.
        /// </summary>
        /// <param name="newFrequency">The frequency to be added.</param>
        public void AddFrequency(ISDBSatelliteFrequency newFrequency)
        {
            foreach (ISDBSatelliteFrequency oldFrequency in Frequencies)
            {
                if (oldFrequency.Frequency == newFrequency.Frequency)
                {
                    if (oldFrequency.Polarization == newFrequency.Polarization)
                        return;
                    else
                    {
                        if (oldFrequency.Polarization.PolarizationAbbreviation.CompareTo(newFrequency.Polarization.PolarizationAbbreviation) > 0)
                        {
                            Frequencies.Insert(Frequencies.IndexOf(oldFrequency), newFrequency);
                            return;
                        }
                    }
                }

                if (oldFrequency.Frequency > newFrequency.Frequency)
                {
                    Frequencies.Insert(Frequencies.IndexOf(oldFrequency), newFrequency);
                    return;
                }
            }

            Frequencies.Add(newFrequency);
        }