Example #1
0
        public void Reset(string frecuency, string alias, bool drawX, bool allAsOneBt, int rtxGroup, Image ptt, Image squelch, Image audio, Color title, Color tx, Color rx, Color txForeColor, Color rxForeColor, Color titleForeColor,
                          string qidxResource, uint qidxValue, FrequencyState state)
        {
            //_Alias = qidxResource;
            _QidxValue = (int)qidxValue;

            Reset(frecuency, alias, drawX, allAsOneBt, rtxGroup, ptt, squelch, audio, title, tx, rx, txForeColor, rxForeColor, titleForeColor, state);
        }
Example #2
0
        public void Reset(RdInfo dst)
        {
            if (dst.Dst == "")
            {
                Reset();
            }
            else
            {
                _Frecuency      = dst.Dst;
                _Alias          = dst.Alias;
                _TempAlias      = string.Empty;
                _Ptt            = dst.Ptt;
                _Squelch        = dst.Squelch;
                _Tx             = dst.Tx;
                _Rx             = dst.Rx || _Tx;
                _AudioVia       = _Rx ? dst.AudioVia : RdRxAudioVia.NoAudio;
                _Monitoring     = dst.Monitoring;//  && !Unavailable;
                _RtxGroup       = _TempRtxGroup = dst.RtxGroup;
                _TipoFrecuencia = dst.TipoFrecuencia;
                _State          = dst.Estado;
                _qidxResource   = _qidxMethod = string.Empty;
                _qidxValue      = 0;
                _RxOnly         = dst.RxOnly;
                /** 20180321. AGL. ALIAS a mostrar en la tecla... */
                if (Properties.Settings.Default.RadioAlias == true)
                {
                    _KeyAlias = dst.KeyAlias == dst.Dst ? "" : dst.KeyAlias;
                }
                else
                {
                    _KeyAlias = (_TempAlias != string.Empty && _TempAlias != _Alias) ? _TempAlias : _Alias;
                }
                /** */

                if (!Restored && Unavailable && (dst.Ptt != PttState.Unavailable || dst.Squelch != SquelchState.Unavailable))
                {
                    _Restored = true;
                }
                else
                {
                    _Restored = false;
                }

                Debug.Assert(!_Rx || (_AudioVia != RdRxAudioVia.NoAudio));
                Debug.Assert(!_Tx || Rx);

                if ((_Squelch == SquelchState.SquelchPortAndMod) && (_Ptt == PttState.PttOnlyPort))
                {
                    _Ptt = PttState.PttPortAndMod;
                }
                else if ((_Squelch == SquelchState.SquelchOnlyPort) && (_Ptt == PttState.PttPortAndMod))
                {
                    _Ptt = PttState.PttOnlyPort;
                }

                //_PttSrcId = dst.PttSrcId;
            }
        }
Example #3
0
        public void Reset(string frecuency, string alias, bool drawX, bool allAsOneBt, int rtxGroup, Image ptt, Image squelch, Image audio, Color title, Color tx, Color rx, Color txForeColor,
                          Color rxForeColor, Color titleForeColor, FrequencyState state = FrequencyState.Available)
        {
            _Frecuency    = frecuency;
            _Alias        = alias.Length > 11 ? (alias.Substring(0, 8) + "...") : alias;
            _RtxGroup     = rtxGroup;
            _PttImage     = ptt;
            _SquelchImage = squelch;

            ForeColor = titleForeColor;
//            BackColor = titleForeColor;
            if (drawX)
            {
                _CurrentBackColor = VisualStyle.ButtonColor;
            }
            else
            {
                if ((title == VisualStyle.Colors.Yellow) || (title == VisualStyle.Colors.Red))
                {
                    _CurrentBackColor = title; //error cases and rtx formation with priority over other colors
                }
                else if (state == FrequencyState.Degraded)
                {
                    _CurrentBackColor = Color.OrangeRed;
                }
                else if (state == FrequencyState.Available)
                {
                    _CurrentBackColor = VisualStyle.ButtonColor;
                }
                else //FrequencyState.NotAvailable
                {
                    _CurrentBackColor = title;
                }
            }

            _BtnInfo.SetBackColor(BtnState.Normal, _CurrentBackColor);
            _TxBtnInfo.SetBackColor(BtnState.Normal, tx);
            _TxBtnInfo.SetForeColor(BtnState.Normal, txForeColor);
            _RxBtnInfo.SetBackColor(BtnState.Normal, rx);
            _RxBtnInfo.SetForeColor(BtnState.Normal, rxForeColor);
            _RxBtnInfo.SetImage(BtnState.Normal, audio);
            _RxBtnInfo.Text = audio == null ? "Rx" : "";

            _DrawX = drawX;

            if (allAsOneBt != _AllAsOneBt)
            {
                _Timer.Enabled = false;
                _State         = BtnState.Normal;
                _StateBT1      = BtnState.Normal;
                _StateBT2      = BtnState.Normal;
                _AllAsOneBt    = allAsOneBt;
            }

            Invalidate();
        }
Example #4
0
 public RdInfo(string dst, string alias, bool tx, bool rx, PttState ptt, SquelchState squelch,
               RdRxAudioVia audioVia, int rtxGroup, TipoFrecuencia_t tipoFrecuencia, bool monitoring, FrequencyState estado, bool rxOnly)
 {
     Dst            = dst;
     Alias          = alias;
     Tx             = tx;
     Rx             = rx;
     Ptt            = ptt;
     Squelch        = squelch;
     AudioVia       = audioVia;
     RtxGroup       = rtxGroup;
     TipoFrecuencia = tipoFrecuencia;
     Monitoring     = monitoring;
     Estado         = estado;
     RxOnly         = rxOnly;
 }
Example #5
0
        public void Reset(RdState st)
        {
            if (Unavailable && (st.Ptt != PttState.Unavailable || st.Squelch != SquelchState.Unavailable))
            {
                _Restored = true;
            }
            else
            {
                _Restored = false;
            }
            _Ptt      = st.Ptt;
            _Squelch  = st.Squelch;
            _Tx       = st.Tx;
            _Rx       = st.Rx || _Tx;                             // || _Monitoring || _Tx;
            _AudioVia = _Rx ? st.AudioVia : RdRxAudioVia.NoAudio; // !_Monitoring ? st.AudioVia : RdRxAudioVia.Speaker;
            if (_RtxGroup != _TempRtxGroup)
            {
                _RtxGroup = st.RtxGroup;
            }
            else
            {
                _RtxGroup = _TempRtxGroup = st.RtxGroup;
            }
            //_RtxGroup = st.RtxGroup;

            Debug.Assert(!_Rx || (_AudioVia != RdRxAudioVia.NoAudio));
            Debug.Assert(!_Tx || Rx);

            if ((_Squelch == SquelchState.SquelchPortAndMod) && (_Ptt == PttState.PttOnlyPort))
            {
                _Ptt = PttState.PttPortAndMod;
            }
            else if ((_Squelch == SquelchState.SquelchOnlyPort) && (_Ptt == PttState.PttPortAndMod))
            {
                _Ptt = PttState.PttOnlyPort;
            }

            // BSS Information
            _qidxMethod   = st.QidxMethod;
            _qidxResource = st.QidxResource;
            _qidxValue    = st.QidxValue;

            _State = st.State;

            _PttSrcId = st.PttSrcId;
        }
Example #6
0
        public RdState(bool tx, bool rx, string pttSrcId, PttState ptt, SquelchState squelch, RdRxAudioVia audioVia, int rtxGroup, FrequencyState state,
                       string qidxMethod, uint qidxValue, string qidxResource)
        {
            Tx       = tx;
            Rx       = rx;
            Ptt      = ptt;
            Squelch  = squelch;
            AudioVia = audioVia;
            RtxGroup = rtxGroup;
            State    = state;
            // BSS Information
            QidxMethod   = qidxMethod;
            QidxValue    = qidxValue;
            QidxResource = qidxResource;

            PttSrcId = pttSrcId;
        }
Example #7
0
 public void ResetToIdle()
 {
     _Tx             = false;
     _Rx             = false;
     _Ptt            = PttState.NoPtt;
     _Squelch        = SquelchState.NoSquelch;
     _AudioVia       = RdRxAudioVia.NoAudio;
     _RtxGroup       = _TempRtxGroup = 0;
     _Monitoring     = false;
     _Restored       = true;
     _TipoFrecuencia = TipoFrecuencia_t.Basica;
     _qidxResource   = _qidxMethod = string.Empty;
     _qidxValue      = 0;
     _State          = FrequencyState.NotAvailable;
     _RxOnly         = false;
     /** 20190205 */
     _PttSrcId = string.Empty;
 }
        private void button2_Click(object sender, RoutedEventArgs e)
        {
            tabControl1.IsEnabled = false;
            FrequencyState[] state           = new FrequencyState[5];
            string           SearchCondition = "";

            #region CheckBoxState
            if (checkBox2.IsChecked == true)
            {
                if (radioButton1.IsChecked == true)
                {
                    state[0]         = FrequencyState.Min;
                    SearchCondition += "SubBass-Min";
                }
                else
                {
                    state[0]         = FrequencyState.Max;
                    SearchCondition += "SubBass-Max ";
                }
            }
            if (checkBox3.IsChecked == true)
            {
                if (radioButton3.IsChecked == true)
                {
                    state[1]         = FrequencyState.Min;
                    SearchCondition += "Bass-Min ";
                }
                else
                {
                    state[1]         = FrequencyState.Max;
                    SearchCondition += "Bass-Max ";
                }
            }
            if (checkBox4.IsChecked == true)
            {
                if (radioButton5.IsChecked == true)
                {
                    state[2]         = FrequencyState.Min;
                    SearchCondition += "Mid-Min ";
                }
                else
                {
                    state[2]         = FrequencyState.Max;
                    SearchCondition += "Mid-Max ";
                }
            }
            if (checkBox5.IsChecked == true)
            {
                if (radioButton7.IsChecked == true)
                {
                    state[3]         = FrequencyState.Min;
                    SearchCondition += "HighMid-Min ";
                }
                else
                {
                    state[3]         = FrequencyState.Max;
                    SearchCondition += "HighMid-Max ";
                }
            }
            if (checkBox6.IsChecked == true)
            {
                if (radioButton9.IsChecked == true)
                {
                    state[4]         = FrequencyState.Min;
                    SearchCondition += "High-Min ";
                }
                else
                {
                    state[4]         = FrequencyState.Max;
                    SearchCondition += "High-Max ";
                }
            }
            #endregion
            int[]     ind       = da.GetSongsBySpectra(state, (int)comboBox1.SelectedValue);
            DataTable TempTable = new DataTable();
            DataRow[] TempRows  = new DataRow[ind.Length];
            for (int k = 0; k < ind.Length; k++)
            {
                DataRow[] dr = dt.Select("song_id=" + ind[k].ToString());
                TempRows[k] = dr[0];
            }
            TempTable = TempRows.CopyToDataTable();
            ShowSongsWindow SpectraSongWindow = new ShowSongsWindow();
            SpectraSongWindow.ToolTip = "Double-click on item to play";
            SpectraSongWindow.Title   = SearchCondition;
            SpectraSongWindow.dataGrid1.DataContext = TempTable;
            SpectraSongWindow.data  = TempTable;
            SpectraSongWindow.Owner = this;
            SpectraSongWindow.Show();
            tabControl1.IsEnabled = true;
        }