kopia lustrzana https://github.com/dl2alf/AirScout
1306 wiersze
47 KiB
C#
1306 wiersze
47 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Configuration;
|
|
using System.Data;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Windows.Forms;
|
|
using System.Xml;
|
|
using System.Xml.Serialization;
|
|
using ScoutBase.Core;
|
|
using ScoutBase.CAT;
|
|
|
|
namespace CATCheck
|
|
{
|
|
public partial class MainDlg : Form
|
|
{
|
|
|
|
private bool Loaded = false;
|
|
private bool Logging = true;
|
|
|
|
private RigParam LastMode = RigParam.pmNone;
|
|
private RigParam LastTx = RigParam.pmNone;
|
|
private RigParam LastVfo = RigParam.pmNone;
|
|
private RigParam LastSplit = RigParam.pmNone;
|
|
private RigParam LastXit = RigParam.pmNone;
|
|
private RigParam LastRit = RigParam.pmNone;
|
|
|
|
private long LastRitOffset = 0;
|
|
|
|
Rig Rig1 = null;
|
|
|
|
private Queue<LogNotifyEventArgs> MsgQueue = new Queue<LogNotifyEventArgs>();
|
|
|
|
public MainDlg()
|
|
{
|
|
InitializeComponent();
|
|
|
|
this.Text = this.Text.Replace("xxx", Application.ProductVersion);
|
|
// set OmniRig rig settings directory
|
|
if (String.IsNullOrEmpty(Properties.Settings.Default.RigDefinitionsFolder))
|
|
{
|
|
Properties.Settings.Default.RigDefinitionsFolder = Path.Combine(Application.StartupPath, "Rigs");
|
|
}
|
|
OmniRig.RigDefinitionsDirectory = Properties.Settings.Default.RigDefinitionsFolder;
|
|
|
|
// start timer
|
|
ti_Main.Start();
|
|
|
|
// subscribe to events
|
|
OmniRig.LogNotify += OmniRig_LogNotify;
|
|
OmniRig.StatusChange += OmniRig_ComNotifyStatus;
|
|
OmniRig.ParamsChange += OmniRig_ComNotifyParams;
|
|
|
|
}
|
|
|
|
private void MainDlg_Load(object sender, EventArgs e)
|
|
{
|
|
|
|
// load user settings
|
|
LoadUserSettings();
|
|
|
|
// set the "Loaded" flag and start rig
|
|
Loaded = true;
|
|
|
|
Rig1 = new Rig();
|
|
RestartRig();
|
|
}
|
|
|
|
|
|
private void MainDlg_FormClosing(object sender, FormClosingEventArgs e)
|
|
{
|
|
SaveUserSettings();
|
|
}
|
|
|
|
#region User Settings
|
|
|
|
private void LoadUserSettings()
|
|
{
|
|
|
|
Console.WriteLine("Loading user settings.");
|
|
|
|
|
|
// generate empty RigSettings object if null
|
|
if (Properties.Settings.Default.RigSettings == null)
|
|
{
|
|
Console.WriteLine("Creating empty rig settings...");
|
|
Properties.Settings.Default.RigSettings = new RigSettings();
|
|
}
|
|
|
|
// initially fill dropdowns
|
|
cb_Rig_DropDown(this, null);
|
|
cb_PortName_DropDown(this, null);
|
|
cb_Baudrate_DropDown(this, null);
|
|
cb_Databits_DropDown(this, null);
|
|
cb_Parity_DropDown(this, null);
|
|
cb_Stopbits_DropDown(this, null);
|
|
cb_RTS_DropDown(this, null);
|
|
cb_DTR_DropDown(this, null);
|
|
|
|
// try to select settings
|
|
try
|
|
{
|
|
cb_Rig.DataSource = OmniRig.SupportedRigs();
|
|
cb_Rig.SelectedItem = Properties.Settings.Default.RigSettings.RigType;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// do nothing if fails
|
|
OmniRig_LogNotify(new LogNotifyEventArgs(DateTime.UtcNow, LOGLEVEL.llError, "Error while setting up rig dropdown: " + ex.Message));
|
|
}
|
|
try
|
|
{
|
|
cb_PortName.SelectedItem = Properties.Settings.Default.RigSettings.PortName;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// do nothing if fails
|
|
OmniRig_LogNotify(new LogNotifyEventArgs(DateTime.UtcNow, LOGLEVEL.llError, "Error while setting up port dropdown: " + ex.Message));
|
|
}
|
|
try
|
|
{
|
|
cb_Baudrate.SelectedItem = Properties.Settings.Default.RigSettings.Baudrate.ToString();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// do nothing if fails
|
|
OmniRig_LogNotify(new LogNotifyEventArgs(DateTime.UtcNow, LOGLEVEL.llError, "Error while setting up baudrate dropdown: " + ex.Message));
|
|
}
|
|
try
|
|
{
|
|
cb_Databits.SelectedItem = Properties.Settings.Default.RigSettings.DataBits.ToString();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// do nothing if fails
|
|
OmniRig_LogNotify(new LogNotifyEventArgs(DateTime.UtcNow, LOGLEVEL.llError, "Error while setting up databits dropdown: " + ex.Message));
|
|
}
|
|
try
|
|
{
|
|
Helpers.BindToEnum<Parity>(cb_Parity);
|
|
cb_Parity.SelectedValue = (int)Properties.Settings.Default.RigSettings.Parity;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// do nothing if fails
|
|
OmniRig_LogNotify(new LogNotifyEventArgs(DateTime.UtcNow, LOGLEVEL.llError, "Error while setting up parity dropdown: " + ex.Message));
|
|
}
|
|
try
|
|
{
|
|
Helpers.BindToEnum<StopBits>(cb_Stopbits);
|
|
cb_Stopbits.SelectedValue = (int)Properties.Settings.Default.RigSettings.StopBits;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// do nothing if fails
|
|
OmniRig_LogNotify(new LogNotifyEventArgs(DateTime.UtcNow, LOGLEVEL.llError, "Error while setting up stopbits dropdown: " + ex.Message));
|
|
}
|
|
try
|
|
{
|
|
Helpers.BindToEnum<FlowControl>(cb_RTS);
|
|
cb_RTS.SelectedValue = (int)Properties.Settings.Default.RigSettings.RtsMode;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// do nothing if fails
|
|
OmniRig_LogNotify(new LogNotifyEventArgs(DateTime.UtcNow, LOGLEVEL.llError, "Error while setting up rts mode dropdown: " + ex.Message));
|
|
}
|
|
try
|
|
{
|
|
Helpers.BindToEnum<FlowControl>(cb_DTR);
|
|
cb_DTR.SelectedValue = (int)Properties.Settings.Default.RigSettings.DtrMode;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// do nothing if fails
|
|
OmniRig_LogNotify(new LogNotifyEventArgs(DateTime.UtcNow, LOGLEVEL.llError, "Error while setting up dtr mode dropdown: " + ex.Message));
|
|
}
|
|
try
|
|
{
|
|
Helpers.BindToEnum<LOGLEVEL>(cb_LogVerbosity);
|
|
cb_LogVerbosity.SelectedValue = (int)Properties.Settings.Default.LogVerbosity;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// do nothing if fails
|
|
OmniRig_LogNotify(new LogNotifyEventArgs(DateTime.UtcNow, LOGLEVEL.llError, "Error while setting up log verbosity dropdown: " + ex.Message));
|
|
}
|
|
try
|
|
{
|
|
ud_PollMs.Value = Properties.Settings.Default.RigSettings.PollMs;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// do nothing if fails
|
|
OmniRig_LogNotify(new LogNotifyEventArgs(DateTime.UtcNow, LOGLEVEL.llError, "Error while setting up PollMs updown: " + ex.Message));
|
|
}
|
|
try
|
|
{
|
|
ud_TimeoutMs.Value = Properties.Settings.Default.RigSettings.TimeoutMs;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// do nothing if fails
|
|
OmniRig_LogNotify(new LogNotifyEventArgs(DateTime.UtcNow, LOGLEVEL.llError, "Error while setting up PollMs updown: " + ex.Message));
|
|
}
|
|
|
|
Console.WriteLine("Loading user settings finished.");
|
|
|
|
}
|
|
|
|
private string GetUserSettingsPath()
|
|
{
|
|
if (!SupportFunctions.IsMono)
|
|
return ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoamingAndLocal).FilePath;
|
|
// try to build a path to user specific settings under Linux/Mono
|
|
string usersettingspath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
|
|
usersettingspath = Path.Combine(usersettingspath, Application.CompanyName, AppDomain.CurrentDomain.FriendlyName);
|
|
usersettingspath += "_Url_";
|
|
Assembly assembly = Assembly.GetEntryAssembly();
|
|
if (assembly == null)
|
|
{
|
|
assembly = Assembly.GetCallingAssembly();
|
|
}
|
|
byte[] pkt = assembly.GetName().GetPublicKeyToken();
|
|
byte[] hash = SHA1.Create().ComputeHash((pkt != null && pkt.Length > 0) ? pkt : Encoding.UTF8.GetBytes(assembly.EscapedCodeBase));
|
|
StringBuilder evidence_string = new StringBuilder();
|
|
byte[] array = hash;
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
byte b = array[i];
|
|
evidence_string.AppendFormat("{0:x2}", b);
|
|
}
|
|
usersettingspath += evidence_string.ToString();
|
|
if (!Directory.Exists(usersettingspath))
|
|
{
|
|
Directory.CreateDirectory(usersettingspath);
|
|
}
|
|
usersettingspath = Path.Combine(usersettingspath, "user.config");
|
|
return usersettingspath;
|
|
}
|
|
|
|
private XmlElement CreateUserSection(XmlDocument doc, SettingsBase settings)
|
|
{
|
|
XmlElement usersection = doc.CreateElement(string.Empty, "section", string.Empty);
|
|
XmlAttribute sectionname = doc.CreateAttribute(string.Empty, "name", string.Empty);
|
|
sectionname.Value = settings.GetType().FullName;
|
|
usersection.Attributes.Append(sectionname);
|
|
XmlAttribute sectiontype = doc.CreateAttribute(string.Empty, "type", string.Empty);
|
|
Assembly assembly = Assembly.GetAssembly(typeof(System.Configuration.ClientSettingsSection));
|
|
// sectiontype.Value = "System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
|
|
sectiontype.Value = typeof(System.Configuration.ClientSettingsSection).FullName + ", " + assembly.FullName;
|
|
usersection.Attributes.Append(sectiontype);
|
|
XmlAttribute sectionallowexedefinition = doc.CreateAttribute(string.Empty, "allowExeDefinition", string.Empty);
|
|
sectionallowexedefinition.Value = "MachineToLocalUser";
|
|
usersection.Attributes.Append(sectionallowexedefinition);
|
|
XmlAttribute sectionrequirepermission = doc.CreateAttribute(string.Empty, "requirePermission", string.Empty);
|
|
sectionrequirepermission.Value = "false";
|
|
usersection.Attributes.Append(sectionrequirepermission);
|
|
return usersection;
|
|
}
|
|
|
|
private XmlElement SerializeSettings(XmlDocument doc, SettingsBase settings)
|
|
{
|
|
XmlElement properties = doc.CreateElement(string.Empty, settings.ToString(), string.Empty);
|
|
foreach (SettingsPropertyValue p in settings.PropertyValues)
|
|
{
|
|
if ((p != null) && (p.Name != null) && (p.PropertyValue != null) && !p.UsingDefaultValue)
|
|
{
|
|
// Console.WriteLine("Appending " + p.Name + " = " + p.PropertyValue.ToString());
|
|
XmlElement setting = doc.CreateElement(string.Empty, "setting", string.Empty);
|
|
XmlAttribute name = doc.CreateAttribute(string.Empty, "name", string.Empty);
|
|
name.Value = p.Name.ToString();
|
|
setting.Attributes.Append(name);
|
|
XmlAttribute serializeas = doc.CreateAttribute(string.Empty, "serializeAs", string.Empty);
|
|
serializeas.Value = p.Property.SerializeAs.ToString();
|
|
setting.Attributes.Append(serializeas);
|
|
XmlElement value = doc.CreateElement(string.Empty, "value", string.Empty);
|
|
if (p.PropertyValue != null && p.Property.SerializeAs == SettingsSerializeAs.String)
|
|
{
|
|
XmlText text = doc.CreateTextNode(p.SerializedValue.ToString());
|
|
value.AppendChild(text);
|
|
}
|
|
else
|
|
{
|
|
if (p.PropertyValue != null && p.Property.SerializeAs == SettingsSerializeAs.Xml)
|
|
{
|
|
MemoryStream ms = new MemoryStream();
|
|
XmlWriter writer = XmlWriter.Create(ms, new XmlWriterSettings
|
|
{
|
|
NewLineOnAttributes = true,
|
|
OmitXmlDeclaration = true
|
|
});
|
|
XmlSerializer serializer = new XmlSerializer(p.PropertyValue.GetType());
|
|
serializer.Serialize(writer, p.PropertyValue);
|
|
byte[] text2 = new byte[ms.ToArray().Length - 3];
|
|
Array.Copy(ms.ToArray(), 3, text2, 0, text2.Length);
|
|
XmlText xml = doc.CreateTextNode(Encoding.UTF8.GetString(text2.ToArray<byte>()));
|
|
value.AppendChild(xml);
|
|
value.InnerXml = WebUtility.HtmlDecode(value.InnerXml);
|
|
}
|
|
}
|
|
setting.AppendChild(value);
|
|
properties.AppendChild(setting);
|
|
}
|
|
}
|
|
return properties;
|
|
}
|
|
|
|
|
|
private void SaveUserSettings()
|
|
{
|
|
try
|
|
{
|
|
if (!SupportFunctions.IsMono)
|
|
{
|
|
Properties.Settings.Default.Save();
|
|
return;
|
|
}
|
|
|
|
// Linux/Mono hack to save all properties in a correct manner
|
|
Console.WriteLine("Saving user settings...");
|
|
Console.WriteLine("Creating XML document...");
|
|
XmlDocument doc = new XmlDocument();
|
|
XmlDeclaration xmlDeclaration = doc.CreateXmlDeclaration("1.0", "UTF-8", null);
|
|
XmlElement root = doc.DocumentElement;
|
|
doc.InsertBefore(xmlDeclaration, root);
|
|
XmlElement configuration = doc.CreateElement(string.Empty, "configuration", string.Empty);
|
|
doc.AppendChild(configuration);
|
|
XmlElement configsections = doc.CreateElement(string.Empty, "configSections", string.Empty);
|
|
configuration.AppendChild(configsections);
|
|
XmlElement usersettingsgroup = doc.CreateElement(string.Empty, "sectionGroup", string.Empty);
|
|
XmlAttribute usersettingsname = doc.CreateAttribute(string.Empty, "name", string.Empty);
|
|
usersettingsname.Value = "userSettings";
|
|
usersettingsgroup.Attributes.Append(usersettingsname);
|
|
usersettingsgroup.AppendChild(CreateUserSection(doc, ScoutBase.CAT.Properties.Settings.Default));
|
|
configsections.AppendChild(usersettingsgroup);
|
|
XmlElement usersettings = doc.CreateElement(string.Empty, "userSettings", string.Empty);
|
|
configuration.AppendChild(usersettings);
|
|
Console.WriteLine("Writing user settings...");
|
|
// append AirScout.CAT properties
|
|
Console.WriteLine("Appending AirScout.CAT.Settings.Default node...");
|
|
usersettings.AppendChild(SerializeSettings(doc, ScoutBase.CAT.Properties.Settings.Default));
|
|
// append properties
|
|
Console.WriteLine("Appending Properties.Settings.Default node...");
|
|
usersettings.AppendChild(SerializeSettings(doc, Properties.Settings.Default));
|
|
doc.Save(GetUserSettingsPath());
|
|
Console.WriteLine("Saving user settings finished.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Unable to save settings: " + ex.ToString());
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
private void cb_Rig_DropDown(object sender, EventArgs e)
|
|
{
|
|
}
|
|
|
|
private void cb_Rig_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// do nothing while loading
|
|
if (!Loaded)
|
|
return;
|
|
|
|
try
|
|
{
|
|
Console.WriteLine("RigType changed to : " + (string)cb_Rig.SelectedItem);
|
|
Properties.Settings.Default.RigSettings.RigType = (string)cb_Rig.SelectedItem;
|
|
SaveUserSettings();
|
|
|
|
//restart rig
|
|
RestartRig();
|
|
}
|
|
catch
|
|
{
|
|
// do nothing if fails
|
|
}
|
|
}
|
|
|
|
private void cb_PortName_DropDown(object sender, EventArgs e)
|
|
{
|
|
cb_PortName.Items.Clear();
|
|
|
|
foreach (string s in System.IO.Ports.SerialPort.GetPortNames())
|
|
{
|
|
cb_PortName.Items.Add(s);
|
|
}
|
|
}
|
|
|
|
private void cb_PortName_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// do nothing while loading
|
|
if (!Loaded)
|
|
return;
|
|
|
|
try
|
|
{
|
|
Console.WriteLine("PortName changed to : " + (string)cb_PortName.SelectedItem);
|
|
Properties.Settings.Default.RigSettings.PortName = (string)cb_PortName.SelectedItem;
|
|
SaveUserSettings();
|
|
|
|
//restart rig
|
|
RestartRig();
|
|
}
|
|
catch
|
|
{
|
|
// do nothing if fails
|
|
}
|
|
}
|
|
|
|
private void cb_Baudrate_DropDown(object sender, EventArgs e)
|
|
{
|
|
cb_Baudrate.Items.Clear();
|
|
string[] baudrates = new string[] { "110", "300", "600", "1200", "2400", "4800", "9600", "14400", "19200", "38400", "56000", "57600", "115200", "128000", "256000"};
|
|
cb_Baudrate.Items.AddRange(baudrates);
|
|
}
|
|
|
|
private void cb_Baudrate_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// do nothing while loading
|
|
if (!Loaded)
|
|
return;
|
|
|
|
try
|
|
{
|
|
Properties.Settings.Default.RigSettings.Baudrate = System.Convert.ToInt32(cb_Baudrate.SelectedItem);
|
|
SaveUserSettings();
|
|
|
|
//restart rig
|
|
RestartRig();
|
|
}
|
|
catch
|
|
{
|
|
// do nothing if fails
|
|
}
|
|
}
|
|
|
|
private void cb_Databits_DropDown(object sender, EventArgs e)
|
|
{
|
|
cb_Databits.Items.Clear();
|
|
string[] databits = new string[] { "5", "6", "7", "8"};
|
|
cb_Databits.Items.AddRange(databits);
|
|
}
|
|
|
|
private void cb_Databits_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
try
|
|
{
|
|
Properties.Settings.Default.RigSettings.DataBits = System.Convert.ToInt32(cb_Databits.SelectedItem);
|
|
SaveUserSettings();
|
|
|
|
//restart rig
|
|
RestartRig();
|
|
}
|
|
catch
|
|
{
|
|
// do nothing if fails
|
|
}
|
|
}
|
|
|
|
private void cb_Parity_DropDown(object sender, EventArgs e)
|
|
{
|
|
}
|
|
|
|
private void cb_Parity_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// do nothing while loading
|
|
if (!Loaded)
|
|
return;
|
|
|
|
try
|
|
{
|
|
if (cb_Parity.SelectedValue != null)
|
|
{
|
|
Properties.Settings.Default.RigSettings.Parity = (Parity)cb_Parity.SelectedValue;
|
|
SaveUserSettings();
|
|
//restart rig
|
|
RestartRig();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// do nothing if fails
|
|
}
|
|
}
|
|
|
|
private void cb_Stopbits_DropDown(object sender, EventArgs e)
|
|
{
|
|
}
|
|
|
|
private void cb_Stopbits_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// do nothing while loading
|
|
if (!Loaded)
|
|
return;
|
|
|
|
try
|
|
{
|
|
if (cb_Stopbits.SelectedValue != null)
|
|
{
|
|
Properties.Settings.Default.RigSettings.StopBits = (StopBits)cb_Stopbits.SelectedValue;
|
|
SaveUserSettings();
|
|
//restart rig
|
|
RestartRig();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// do nothing if fails
|
|
}
|
|
}
|
|
|
|
private void cb_RTS_DropDown(object sender, EventArgs e)
|
|
{
|
|
}
|
|
|
|
private void cb_RTS_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// do nothing while loading
|
|
if (!Loaded)
|
|
return;
|
|
|
|
try
|
|
{
|
|
if (cb_RTS.SelectedValue != null)
|
|
{
|
|
Properties.Settings.Default.RigSettings.RtsMode = (FlowControl)cb_RTS.SelectedValue;
|
|
SaveUserSettings();
|
|
//restart rig
|
|
RestartRig();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// do nothing if fails
|
|
}
|
|
}
|
|
|
|
private void cb_DTR_DropDown(object sender, EventArgs e)
|
|
{
|
|
}
|
|
|
|
private void cb_DTR_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// do nothing while loading
|
|
if (!Loaded)
|
|
return;
|
|
|
|
try
|
|
{
|
|
if (cb_DTR.SelectedValue != null)
|
|
{
|
|
Properties.Settings.Default.RigSettings.DtrMode = (FlowControl)cb_DTR.SelectedValue;
|
|
SaveUserSettings();
|
|
//restart rig
|
|
RestartRig();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// do nothing if fails
|
|
}
|
|
}
|
|
|
|
private void cb_LogVerbosity_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// do nothing while loading
|
|
if (!Loaded)
|
|
return;
|
|
|
|
try
|
|
{
|
|
if (cb_LogVerbosity != null)
|
|
{
|
|
Properties.Settings.Default.LogVerbosity = (LOGLEVEL)cb_LogVerbosity.SelectedValue;
|
|
SaveUserSettings();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// do nothing if fails
|
|
}
|
|
}
|
|
|
|
private void ud_PollMs_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
if (!Loaded)
|
|
return;
|
|
|
|
try
|
|
{
|
|
Properties.Settings.Default.RigSettings.PollMs = (int)ud_PollMs.Value;
|
|
}
|
|
catch
|
|
{
|
|
// do nothing if fails
|
|
}
|
|
|
|
RestartRig();
|
|
}
|
|
|
|
private void ud_TimeoutMs_ValueChanged(object sender, EventArgs e)
|
|
{
|
|
if (!Loaded)
|
|
return;
|
|
|
|
try
|
|
{
|
|
Properties.Settings.Default.RigSettings.TimeoutMs = (int)ud_TimeoutMs.Value;
|
|
}
|
|
catch
|
|
{
|
|
// do nothing if fails
|
|
}
|
|
RestartRig();
|
|
}
|
|
|
|
private void btn_Configurations_Folder_Click(object sender, EventArgs e)
|
|
{
|
|
FolderBrowserDialog Dlg = new FolderBrowserDialog();
|
|
if (!String.IsNullOrEmpty(Properties.Settings.Default.RigDefinitionsFolder))
|
|
{
|
|
Dlg.SelectedPath = Properties.Settings.Default.RigDefinitionsFolder;
|
|
}
|
|
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
if (Directory.Exists(Dlg.SelectedPath))
|
|
{
|
|
Properties.Settings.Default.RigDefinitionsFolder = Dlg.SelectedPath;
|
|
SaveUserSettings();
|
|
OmniRig.RigDefinitionsDirectory = Properties.Settings.Default.RigDefinitionsFolder;
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Selected path does not exist!", "Select Rig Definitions Folder");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void btn_Restart_Click(object sender, EventArgs e)
|
|
{
|
|
RestartRig();
|
|
}
|
|
|
|
private void btn_Log_StartStop_Click(object sender, EventArgs e)
|
|
{
|
|
if (Logging)
|
|
{
|
|
btn_Log_StartStop.Text = "Start Log";
|
|
Logging = false;
|
|
}
|
|
else
|
|
{
|
|
btn_Log_StartStop.Text = "Stop Log";
|
|
Logging = true;
|
|
}
|
|
}
|
|
|
|
private void btn_Log_Clear_Click(object sender, EventArgs e)
|
|
{
|
|
lv_Messages.Items.Clear();
|
|
}
|
|
|
|
private void btn_Log_Show_Click(object sender, EventArgs e)
|
|
{
|
|
// get log directory, set application dir if not specified
|
|
string dir = Path.GetDirectoryName(OmniRig.LogFileName);
|
|
if (String.IsNullOrEmpty(dir))
|
|
{
|
|
dir = Application.StartupPath;
|
|
}
|
|
|
|
Process.Start("explorer.exe", dir);
|
|
}
|
|
|
|
private void lbl_Freq_Click(object sender, EventArgs e)
|
|
{
|
|
// return if param is not writeable
|
|
if (!Rig1.RigCommands.WriteableParams.Contains(RigParam.pmFreq))
|
|
return;
|
|
SetFrequencyDlg Dlg = new SetFrequencyDlg();
|
|
Dlg.ud_Frequency.Value = Rig1.Freq;
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
Rig1.Freq = (int)Dlg.ud_Frequency.Value;
|
|
}
|
|
}
|
|
|
|
private void lbl_FreqA_Click(object sender, EventArgs e)
|
|
{
|
|
// return if param is not writeable
|
|
if (!Rig1.RigCommands.WriteableParams.Contains(RigParam.pmFreqA))
|
|
return;
|
|
SetFrequencyDlg Dlg = new SetFrequencyDlg();
|
|
Dlg.ud_Frequency.Value = Rig1.FreqA;
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
Rig1.FreqA = (int)Dlg.ud_Frequency.Value;
|
|
}
|
|
}
|
|
|
|
private void lbl_FreqB_Click(object sender, EventArgs e)
|
|
{
|
|
// return if param is not writeable
|
|
if (!Rig1.RigCommands.WriteableParams.Contains(RigParam.pmFreqB))
|
|
return;
|
|
SetFrequencyDlg Dlg = new SetFrequencyDlg();
|
|
Dlg.ud_Frequency.Value = Rig1.FreqB;
|
|
if (Dlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
Rig1.FreqB = (int)Dlg.ud_Frequency.Value;
|
|
}
|
|
}
|
|
|
|
private void lbl_CW_U_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Mode = RigParam.pmCW_U;
|
|
}
|
|
|
|
private void lbl_CW_L_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Mode = RigParam.pmCW_L;
|
|
}
|
|
|
|
private void lbl_SSB_U_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Mode = RigParam.pmSSB_U;
|
|
}
|
|
|
|
private void lbl_SSB_L_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Mode = RigParam.pmSSB_L;
|
|
}
|
|
|
|
private void lbl_DIG_U_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Mode = RigParam.pmDIG_U;
|
|
}
|
|
|
|
private void lbl_DIG_L_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Mode = RigParam.pmDIG_L;
|
|
}
|
|
|
|
private void lbl_AM_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Mode = RigParam.pmAM;
|
|
}
|
|
|
|
private void lbl_FM_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Mode = RigParam.pmFM;
|
|
}
|
|
|
|
private void lbl_TX_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Tx = RigParam.pmTx;
|
|
}
|
|
|
|
private void lbl_RX_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Tx = RigParam.pmRx;
|
|
}
|
|
|
|
private void lbl_VFO_AA_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Vfo = RigParam.pmVfoAA;
|
|
}
|
|
|
|
private void lbl_VFO_AB_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Vfo = RigParam.pmVfoAB;
|
|
}
|
|
|
|
private void lbl_VFO_BA_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Vfo = RigParam.pmVfoBA;
|
|
}
|
|
|
|
private void lbl_VFO_BB_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Vfo = RigParam.pmVfoBB;
|
|
}
|
|
|
|
private void lbl_VFO_A_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Vfo = RigParam.pmVfoA;
|
|
}
|
|
|
|
private void lbl_VFO_B_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Vfo = RigParam.pmVfoB;
|
|
}
|
|
|
|
private void lbl_VFO_Equal_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Vfo = RigParam.pmVfoEqual;
|
|
}
|
|
|
|
private void lbl_VFO_Swap_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Vfo = RigParam.pmVfoSwap;
|
|
}
|
|
|
|
private void lbl_SPLIT_ON_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Split = RigParam.pmSplitOn;
|
|
}
|
|
|
|
private void lbl_SPLIT_OFF_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Split = RigParam.pmSplitOff;
|
|
}
|
|
|
|
private void lbl_XIT_ON_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Xit = RigParam.pmXitOn;
|
|
}
|
|
|
|
private void lbl_XIT_OFF_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Xit = RigParam.pmXitOff;
|
|
}
|
|
|
|
private void lbl_RIT_ON_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Rit = RigParam.pmRitOn;
|
|
}
|
|
|
|
private void lbl_RIT_OFF_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Rit = RigParam.pmRitOff;
|
|
}
|
|
|
|
private void lbl_RIT_0_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.Rit = RigParam.pmRit0;
|
|
}
|
|
|
|
private void lbl_RTS_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.PortBits.Rts = !Rig1.PortBits.Rts;
|
|
}
|
|
|
|
private void lbl_DTR_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.PortBits.Dtr = !Rig1.PortBits.Dtr;
|
|
}
|
|
|
|
|
|
// special functions
|
|
private void mni_ClearRIT_Click(object sender, EventArgs e)
|
|
{
|
|
Rig1.ClearRit();
|
|
}
|
|
|
|
private void mni_FrequencyOfTone_Click(object sender, EventArgs e)
|
|
{
|
|
FrequencyOfToneDlg Dlg = new FrequencyOfToneDlg(Rig1);
|
|
Dlg.Show();
|
|
}
|
|
|
|
private void RestartRig()
|
|
{
|
|
// suppress restarts until fully loaded
|
|
if (Loaded)
|
|
{
|
|
// stop rig if running
|
|
if (Rig1.Enabled)
|
|
{
|
|
Rig1.Enabled = false;
|
|
}
|
|
|
|
DateTime timeout = DateTime.Now.AddMilliseconds((int)Properties.Settings.Default.RigSettings.TimeoutMs);
|
|
do
|
|
{
|
|
Application.DoEvents();
|
|
if (DateTime.Now > timeout)
|
|
{
|
|
OmniRig_LogNotify(new LogNotifyEventArgs(DateTime.UtcNow, LOGLEVEL.llError, "Cannot not stop rig!"));
|
|
break;
|
|
}
|
|
}
|
|
while (Rig1.Enabled);
|
|
|
|
// clear log
|
|
if (File.Exists(OmniRig.LogFileName))
|
|
{
|
|
try
|
|
{
|
|
File.Delete(OmniRig.LogFileName);
|
|
}
|
|
catch
|
|
{
|
|
// do nothing
|
|
}
|
|
}
|
|
// refresh settings
|
|
Rig1.RigNumber = 1;
|
|
Properties.Settings.Default.RigSettings.ToRig(Rig1);
|
|
// start rig
|
|
Rig1.Enabled = true;
|
|
|
|
}
|
|
}
|
|
|
|
private void OmniRig_LogNotify(LogNotifyEventArgs args)
|
|
{
|
|
if (!Logging)
|
|
return;
|
|
|
|
// queue message
|
|
MsgQueue.Enqueue(args);
|
|
}
|
|
|
|
private void OmniRig_ComNotifyParams(int rignumber, int Params)
|
|
{
|
|
|
|
// set frequencies
|
|
tb_Freq.Text = Rig1.Freq.ToString();
|
|
tb_FreqA.Text = Rig1.FreqA.ToString();
|
|
tb_FreqB.Text = Rig1.FreqB.ToString();
|
|
|
|
// set mode
|
|
if (LastMode != Rig1.Mode)
|
|
{
|
|
SetLabelStyle(lbl_CW_L, RigParam.pmCW_L, false);
|
|
SetLabelStyle(lbl_CW_U, RigParam.pmCW_U, false);
|
|
SetLabelStyle(lbl_SSB_L, RigParam.pmSSB_L, false);
|
|
SetLabelStyle(lbl_SSB_U, RigParam.pmSSB_U, false);
|
|
SetLabelStyle(lbl_DIG_L, RigParam.pmDIG_L, false);
|
|
SetLabelStyle(lbl_DIG_U, RigParam.pmDIG_U, false);
|
|
SetLabelStyle(lbl_AM, RigParam.pmAM, false);
|
|
SetLabelStyle(lbl_FM, RigParam.pmFM, false);
|
|
|
|
switch (Rig1.Mode)
|
|
{
|
|
case RigParam.pmCW_U: SetLabelStyle(lbl_CW_U, RigParam.pmCW_U, true, 1); break;
|
|
case RigParam.pmCW_L: SetLabelStyle(lbl_CW_L, RigParam.pmCW_L, true, 1); break;
|
|
case RigParam.pmSSB_U: SetLabelStyle(lbl_SSB_U, RigParam.pmSSB_U, true, 1);break;
|
|
case RigParam.pmSSB_L: SetLabelStyle(lbl_SSB_L, RigParam.pmSSB_L, true, 1); break;
|
|
case RigParam.pmDIG_U: SetLabelStyle(lbl_DIG_U, RigParam.pmDIG_U, true, 1); break;
|
|
case RigParam.pmDIG_L: SetLabelStyle(lbl_DIG_L, RigParam.pmDIG_L, true, 1); break;
|
|
case RigParam.pmAM: SetLabelStyle(lbl_AM, RigParam.pmAM, true, 1); break;
|
|
case RigParam.pmFM: SetLabelStyle(lbl_FM, RigParam.pmFM, true, 1); break;
|
|
}
|
|
|
|
LastMode = Rig1.Mode;
|
|
}
|
|
|
|
// set TX
|
|
if (LastTx != Rig1.Tx)
|
|
{
|
|
SetLabelStyle(lbl_RX, RigParam.pmRx, false);
|
|
SetLabelStyle(lbl_TX, RigParam.pmTx, false);
|
|
|
|
switch (Rig1.Tx)
|
|
{
|
|
case RigParam.pmRx: SetLabelStyle(lbl_RX, RigParam.pmRx, true, 1); break;
|
|
case RigParam.pmTx: SetLabelStyle(lbl_TX, RigParam.pmTx, true, 2); break;
|
|
}
|
|
|
|
LastTx = Rig1.Tx;
|
|
}
|
|
|
|
// set VFO
|
|
if (LastVfo != Rig1.Vfo)
|
|
{
|
|
SetLabelStyle(lbl_VFO_AA, RigParam.pmVfoAA, false);
|
|
SetLabelStyle(lbl_VFO_AB, RigParam.pmVfoAB, false);
|
|
SetLabelStyle(lbl_VFO_BA, RigParam.pmVfoBA, false);
|
|
SetLabelStyle(lbl_VFO_BB, RigParam.pmVfoBB, false);
|
|
SetLabelStyle(lbl_VFO_A, RigParam.pmVfoA, false);
|
|
SetLabelStyle(lbl_VFO_B, RigParam.pmVfoB, false);
|
|
SetLabelStyle(lbl_VFO_Equal, RigParam.pmVfoEqual, false);
|
|
SetLabelStyle(lbl_VFO_Swap, RigParam.pmVfoSwap, false);
|
|
|
|
switch (Rig1.Vfo)
|
|
{
|
|
case RigParam.pmVfoAA: SetLabelStyle(lbl_VFO_AA, RigParam.pmVfoAA, true, 1); break;
|
|
case RigParam.pmVfoAB: SetLabelStyle(lbl_VFO_AB, RigParam.pmVfoAB, true, 1); break;
|
|
case RigParam.pmVfoBA: SetLabelStyle(lbl_VFO_BA, RigParam.pmVfoBA, true, 1); break;
|
|
case RigParam.pmVfoBB: SetLabelStyle(lbl_VFO_BB, RigParam.pmVfoBB, true, 1); break;
|
|
case RigParam.pmVfoA: SetLabelStyle(lbl_VFO_A, RigParam.pmVfoA, true, 1); break;
|
|
case RigParam.pmVfoB: SetLabelStyle(lbl_VFO_B, RigParam.pmVfoB, true, 1); break;
|
|
case RigParam.pmVfoEqual: SetLabelStyle(lbl_VFO_Equal, RigParam.pmVfoEqual, true, 1); break;
|
|
case RigParam.pmVfoSwap: SetLabelStyle(lbl_VFO_Swap, RigParam.pmVfoSwap, true, 1); break;
|
|
}
|
|
|
|
LastVfo = Rig1.Vfo;
|
|
}
|
|
|
|
// set split
|
|
if (LastSplit != Rig1.Split)
|
|
{
|
|
SetLabelStyle(lbl_SPLIT_ON, RigParam.pmSplitOn, false);
|
|
SetLabelStyle(lbl_SPLIT_OFF, RigParam.pmSplitOff, false);
|
|
|
|
switch (Rig1.Split)
|
|
{
|
|
case RigParam.pmSplitOn: SetLabelStyle(lbl_SPLIT_ON, RigParam.pmSplitOn, true, 1); break;
|
|
case RigParam.pmSplitOff: SetLabelStyle(lbl_SPLIT_OFF, RigParam.pmSplitOff, true, 1); break;
|
|
}
|
|
|
|
LastSplit = Rig1.Split;
|
|
}
|
|
|
|
// set xit
|
|
if (LastXit != Rig1.Xit)
|
|
{
|
|
SetLabelStyle(lbl_XIT_ON, RigParam.pmXitOn, false);
|
|
SetLabelStyle(lbl_XIT_OFF, RigParam.pmXitOff, false);
|
|
|
|
switch (Rig1.Xit)
|
|
{
|
|
case RigParam.pmXitOn: SetLabelStyle(lbl_XIT_ON, RigParam.pmXitOn, true, 1); break;
|
|
case RigParam.pmXitOff: SetLabelStyle(lbl_XIT_OFF, RigParam.pmXitOff, true, 1); break;
|
|
}
|
|
|
|
LastXit = Rig1.Xit;
|
|
}
|
|
|
|
// set rit
|
|
if (LastRit != Rig1.Rit)
|
|
{
|
|
SetLabelStyle(lbl_RIT_ON, RigParam.pmRitOn, false);
|
|
SetLabelStyle(lbl_RIT_OFF, RigParam.pmRitOff, false);
|
|
|
|
switch (Rig1.Rit)
|
|
{
|
|
case RigParam.pmRitOn: SetLabelStyle(lbl_RIT_ON, RigParam.pmRitOn, true, 1); break;
|
|
case RigParam.pmRitOff: SetLabelStyle(lbl_RIT_OFF, RigParam.pmRitOff, true, 1); break;
|
|
}
|
|
|
|
LastRit = Rig1.Rit;
|
|
}
|
|
|
|
// set rit offset
|
|
if (LastRitOffset != Rig1.RitOffset)
|
|
{
|
|
// show RIT offset in kHz
|
|
lbl_RIT_OFS.Text = (Rig1.RitOffset/1000.0).ToString("0.00");
|
|
LastRitOffset = Rig1.RitOffset;
|
|
}
|
|
|
|
|
|
Application.DoEvents();
|
|
}
|
|
|
|
private void SetLabelStyle(Label label, RigParam param, bool on, int color = 1)
|
|
{
|
|
// calculate color
|
|
Color c = Color.Transparent;
|
|
switch (color)
|
|
{
|
|
case 1: c = Color.Chartreuse; break;
|
|
case 2: c = Color.LightSalmon; break;
|
|
default: c = Color.LightGray; break;
|
|
}
|
|
|
|
// set colors according to read/write caps
|
|
if (!Rig1.RigCommands.ReadableParams.Contains(param) && !Rig1.RigCommands.WriteableParams.Contains(param))
|
|
{
|
|
label.BorderStyle = BorderStyle.Fixed3D;
|
|
label.ForeColor = Color.Gray;
|
|
label.BackColor = Color.LightGray;
|
|
tt_Set.SetToolTip(label, "Not writeable!");
|
|
}
|
|
else if (Rig1.RigCommands.ReadableParams.Contains(param) && !Rig1.RigCommands.WriteableParams.Contains(param))
|
|
{
|
|
label.BorderStyle = BorderStyle.FixedSingle;
|
|
label.ForeColor = Color.Black;
|
|
label.BackColor = on ? c : Color.FloralWhite;
|
|
tt_Set.SetToolTip(label, "Not writeable!");
|
|
}
|
|
else if (!Rig1.RigCommands.ReadableParams.Contains(param) && Rig1.RigCommands.WriteableParams.Contains(param))
|
|
{
|
|
label.BorderStyle = BorderStyle.FixedSingle;
|
|
label.BackColor = Color.LightGray;
|
|
label.ForeColor = Color.Black;
|
|
tt_Set.SetToolTip(label, "Click to send command!");
|
|
}
|
|
else if (Rig1.RigCommands.ReadableParams.Contains(param) && Rig1.RigCommands.WriteableParams.Contains(param))
|
|
{
|
|
label.ForeColor = Color.Black;
|
|
label.BorderStyle = BorderStyle.FixedSingle;
|
|
label.BackColor = on ? c : Color.White;
|
|
tt_Set.SetToolTip(label, "Click to send command!");
|
|
}
|
|
}
|
|
|
|
private void SetTextBoxStyle(TextBox textbox, RigParam param, bool on, int color = 1)
|
|
{
|
|
// calculate color
|
|
Color c = Color.Transparent;
|
|
switch (color)
|
|
{
|
|
case 1: c = Color.Chartreuse; break;
|
|
case 2: c = Color.LightSalmon; break;
|
|
default: c = Color.LightGray; break;
|
|
}
|
|
|
|
// set colors according to read/write caps
|
|
if (!Rig1.RigCommands.ReadableParams.Contains(param))
|
|
{
|
|
textbox.BorderStyle = BorderStyle.Fixed3D;
|
|
textbox.ForeColor = Color.Gray;
|
|
textbox.BackColor = Color.LightGray;
|
|
}
|
|
else
|
|
{
|
|
textbox.BorderStyle = BorderStyle.FixedSingle;
|
|
textbox.ForeColor = c;
|
|
textbox.BackColor = Color.Gray;
|
|
tt_Set.SetToolTip(textbox, "Not writeable!");
|
|
}
|
|
}
|
|
|
|
private void OmniRig_ComNotifyStatus(int rignumber)
|
|
{
|
|
RigCtlStatus status = Rig1.Status;
|
|
|
|
// reset all last values to None if offline
|
|
if (status != RigCtlStatus.stOnLine)
|
|
{
|
|
LastMode = RigParam.pmNone;
|
|
LastTx = RigParam.pmNone;
|
|
LastVfo = RigParam.pmNone;
|
|
LastSplit = RigParam.pmNone;
|
|
LastXit = RigParam.pmNone;
|
|
LastRit = RigParam.pmNone;
|
|
|
|
LastRitOffset = 0;
|
|
|
|
}
|
|
|
|
// show status text in text box
|
|
tb_Status.Text = Rig1.StatusStr;
|
|
|
|
// enable/disable elements according to rig capabilities
|
|
SetTextBoxStyle(tb_Freq, RigParam.pmFreq,false);
|
|
SetTextBoxStyle(tb_FreqA, RigParam.pmFreqA, false);
|
|
SetTextBoxStyle(tb_FreqB, RigParam.pmFreqB, false);
|
|
|
|
SetLabelStyle(lbl_Freq, RigParam.pmFreq, false);
|
|
SetLabelStyle(lbl_FreqA, RigParam.pmFreqA, false);
|
|
SetLabelStyle(lbl_FreqB, RigParam.pmFreqB, false);
|
|
|
|
// initially set all buttons
|
|
SetLabelStyle(lbl_CW_L, RigParam.pmCW_L, false);
|
|
SetLabelStyle(lbl_CW_U, RigParam.pmCW_U, false);
|
|
SetLabelStyle(lbl_SSB_L, RigParam.pmSSB_L, false);
|
|
SetLabelStyle(lbl_SSB_U, RigParam.pmSSB_U, false);
|
|
SetLabelStyle(lbl_DIG_L, RigParam.pmDIG_L, false);
|
|
SetLabelStyle(lbl_DIG_U, RigParam.pmDIG_U, false);
|
|
SetLabelStyle(lbl_AM, RigParam.pmAM, false);
|
|
SetLabelStyle(lbl_FM, RigParam.pmFM, false);
|
|
|
|
SetLabelStyle(lbl_RX, RigParam.pmRx, false);
|
|
SetLabelStyle(lbl_TX, RigParam.pmTx, false);
|
|
|
|
SetLabelStyle(lbl_VFO_AA, RigParam.pmVfoAA, false);
|
|
SetLabelStyle(lbl_VFO_AB, RigParam.pmVfoAB, false);
|
|
SetLabelStyle(lbl_VFO_BA, RigParam.pmVfoBA, false);
|
|
SetLabelStyle(lbl_VFO_BB, RigParam.pmVfoBB, false);
|
|
SetLabelStyle(lbl_VFO_A, RigParam.pmVfoA, false);
|
|
SetLabelStyle(lbl_VFO_B, RigParam.pmVfoB, false);
|
|
SetLabelStyle(lbl_VFO_Equal, RigParam.pmVfoEqual, false);
|
|
SetLabelStyle(lbl_VFO_Swap, RigParam.pmVfoSwap, false);
|
|
|
|
SetLabelStyle(lbl_SPLIT_ON, RigParam.pmSplitOn, false);
|
|
SetLabelStyle(lbl_SPLIT_OFF, RigParam.pmSplitOff, false);
|
|
|
|
SetLabelStyle(lbl_XIT_ON, RigParam.pmXitOn, false);
|
|
SetLabelStyle(lbl_XIT_OFF, RigParam.pmXitOff, false);
|
|
|
|
SetLabelStyle(lbl_RIT_ON, RigParam.pmRitOn, false);
|
|
SetLabelStyle(lbl_RIT_OFF, RigParam.pmRitOff, false);
|
|
SetLabelStyle(lbl_RIT_OFS, RigParam.pmRitOffset, false);
|
|
|
|
// show status lines
|
|
if (status != RigCtlStatus.stPortBusy)
|
|
{
|
|
lbl_RTS.BackColor = (Rig1.PortBits.Rts) ? Color.Red : Color.Chartreuse;
|
|
lbl_DTR.BackColor = (Rig1.PortBits.Dtr) ? Color.Red : Color.Chartreuse;
|
|
lbl_CTS.BackColor = (Rig1.PortBits.Cts) ? Color.Red : Color.Chartreuse;
|
|
lbl_DSR.BackColor = (Rig1.PortBits.Dsr) ? Color.Red : Color.Chartreuse;
|
|
tt_Set.SetToolTip(lbl_RTS, "Click to toggle!");
|
|
tt_Set.SetToolTip(lbl_DTR, "Click to toggle!");
|
|
}
|
|
else
|
|
{
|
|
lbl_RTS.BackColor = Color.LightGray;
|
|
lbl_DTR.BackColor = Color.LightGray;
|
|
lbl_CTS.BackColor = Color.LightGray;
|
|
lbl_DSR.BackColor = Color.LightGray;
|
|
tt_Set.SetToolTip(lbl_RTS, "");
|
|
tt_Set.SetToolTip(lbl_DTR, "");
|
|
}
|
|
}
|
|
|
|
private void mni_Exit_Click(object sender, EventArgs e)
|
|
{
|
|
this.Close();
|
|
}
|
|
|
|
private void mni_About_Click(object sender, EventArgs e)
|
|
{
|
|
AboutDlg Dlg = new AboutDlg();
|
|
Dlg.lbl_Version.Text = Dlg.lbl_Version.Text.Replace("x.x.x", Application.ProductVersion.ToString());
|
|
Dlg.ShowDialog();
|
|
}
|
|
|
|
private void lv_Messages_DrawColumnHeader(object sender, DrawListViewColumnHeaderEventArgs e)
|
|
{
|
|
// Draw the header background
|
|
e.Graphics.FillRectangle(Brushes.LightCyan, e.Bounds);
|
|
|
|
// Draw the header text
|
|
Font font = new Font("Courier New", 8, FontStyle.Bold);
|
|
StringFormat sf = new StringFormat();
|
|
sf.Alignment = StringAlignment.Near;
|
|
sf.LineAlignment = StringAlignment.Center;
|
|
e.Graphics.DrawString(e.Header.Text, font, Brushes.Black, e.Bounds, sf);
|
|
}
|
|
|
|
private void lv_Messages_DrawItem(object sender, DrawListViewItemEventArgs e)
|
|
{
|
|
e.DrawDefault = true;
|
|
}
|
|
|
|
private void lv_Messages_DrawSubItem(object sender, DrawListViewSubItemEventArgs e)
|
|
{
|
|
e.DrawDefault = true;
|
|
}
|
|
|
|
private void ti_Main_Tick(object sender, EventArgs e)
|
|
{
|
|
// stop timer
|
|
ti_Main.Stop();
|
|
|
|
try
|
|
{
|
|
// show msg queue count
|
|
lbl_Queue.Text = MsgQueue.Count.ToString();
|
|
lbl_Queue.Refresh();
|
|
|
|
lock (MsgQueue)
|
|
{
|
|
while (MsgQueue.Count > 0)
|
|
{
|
|
// get message
|
|
LogNotifyEventArgs args = MsgQueue.Dequeue();
|
|
|
|
if (args.LogLevel >= Properties.Settings.Default.LogVerbosity)
|
|
{
|
|
lv_Messages.BeginUpdate();
|
|
|
|
// maintain size
|
|
while (lv_Messages.Items.Count > 100)
|
|
{
|
|
lv_Messages.Items.RemoveAt(0);
|
|
}
|
|
|
|
// add new entry
|
|
ListViewItem item = new ListViewItem();
|
|
item.ImageIndex = ((int)args.LogLevel) - 1;
|
|
item.SubItems.Add(args.TimeStamp.ToString("yyyy-MM-dd HH:mm:ss,fff"));
|
|
item.SubItems.Add(args.Message);
|
|
lv_Messages.Items.Add(item);
|
|
|
|
lv_Messages.EndUpdate();
|
|
|
|
lv_Messages.Items[lv_Messages.Items.Count - 1].EnsureVisible();
|
|
|
|
// check for application events
|
|
Application.DoEvents();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error while adding message to list: " + ex.Message);
|
|
}
|
|
|
|
// restart timer
|
|
ti_Main.Start();
|
|
}
|
|
|
|
}
|
|
}
|