public void _build_config()
{
var cmd_queue = this._mcu.alloc_command_queue();
var cycle_ticks = this._mcu.seconds_to_clock(this._cycle_time);
if (this._hardware_pwm)
{
this._pwm_max = this._mcu.get_constant_float("PWM_MAX");
if (this._is_static)
{
this._mcu.add_config_cmd($"set_pwm_out pin={this._pin} cycle_ticks={cycle_ticks} value={this._start_value * this._pwm_max}");
return;
}
this._oid = this._mcu.create_oid();
this._mcu.add_config_cmd($"config_pwm_out oid={this._oid} pin={this._pin} cycle_ticks={cycle_ticks} value={this._start_value * this._pwm_max} default_value={this._shutdown_value * this._pwm_max} max_duration={this._mcu.seconds_to_clock(this._max_duration)}");
this._set_cmd = this._mcu.lookup_command("schedule_pwm_out oid=%c clock=%u value=%hu", cq: cmd_queue);
}
else
{
if (!(this._start_value == 0.0 || this._start_value == 1.0) &&
!(this._shutdown_value == 0.0 || this._shutdown_value == 1.0))
{
throw new PinsException("start and shutdown values must be 0.0 or 1.0 on soft pwm");
}
this._pwm_max = this._mcu.get_constant_float("SOFT_PWM_MAX");
if (this._is_static)
{
this._mcu.add_config_cmd($"set_digital_out pin={this._pin} value={(this._start_value >= 0.5 ? 1 : 0)}");
return;
}
this._oid = this._mcu.create_oid();
this._mcu.add_config_cmd($"config_soft_pwm_out oid={this._oid} pin={this._pin} cycle_ticks={cycle_ticks} value={(this._start_value >= 0.5 ? 1 : 0)} default_value={(this._shutdown_value >= 0.5 ? 1 : 0)} max_duration={this._mcu.seconds_to_clock(this._max_duration)}");
this._set_cmd = this._mcu.lookup_command("schedule_soft_pwm_out oid=%c clock=%u value=%hu", cq: cmd_queue);
}
}
public static string ToString(this SerialCommand val)
{
DescriptionAttribute[] attributes = (DescriptionAttribute[])val
.GetType()
.GetField(val.ToString())
.GetCustomAttributes(typeof(DescriptionAttribute), false);
return(attributes.Length > 0 ? attributes[0].Description : string.Empty);
}
public SerialBootStrap(SerialReader serial)
{
logging.Info("start load identify_data");
this.serial = serial;
identify_data = new MemoryStream();
identify_cmd = this.serial.lookup_command("identify offset=%u count=%c");
this.serial.register_callback(handle_identify, "identify_response");
this.serial.register_callback(handle_unknown, "#unknown");
this.send_timer = this.serial.reactor.register_timer(this.send_event, SelectReactor.NOW);
}
private static byte[] RawSerialize(SerialCommand anything)
{
List<byte> Res = new List<byte>();
Res.AddRange(BitConverter.GetBytes(anything.cmd).Take(1));
Res.AddRange(BitConverter.GetBytes(anything.Pipe).Take(8));
Res.AddRange(BitConverter.GetBytes(anything.DataSize).Take(2));
Res.AddRange(BitConverter.GetBytes(anything.TimeOut).Take(4));
Res.AddRange(anything.CryptoKey);
return Res.ToArray();
}
public void ConstructHoldFingersTest(int[] selectedFingers, string expected)
{
ISerialPort port = mock.Object;
SerialCommand command = new SerialCommand(port);
string actual = command.MoveFingers(selectedFingers, true);
Assert.Equal(expected, actual);
}
private string GetCommandString(SerialCommand Command)
{
switch (Command)
{
case SerialCommand.SerialNumber:
{
return("SN");
}
case SerialCommand.SerialAcknowledge:
{
return("SA");
}
case SerialCommand.DeviceReady:
{
return("RD");
}
case SerialCommand.ShowPattern:
{
return("SP");
}
case SerialCommand.PatternAcknowledge:
{
return("PA");
}
case SerialCommand.Unload:
{
return("UL");
}
case SerialCommand.UnloadAcknowledge:
{
return("UA");
}
case SerialCommand.Result:
{
return("RS");
}
case SerialCommand.ResultAcknowledge:
{
return("RA");
}
default:
{
return(null);
}
}
}
public void ConstructStatusCheckTest()
{
ISerialPort port = mock.Object;
SerialCommand command = new SerialCommand(port);
string expected = "0";
string actual = command.StatusCheck();
Assert.Equal(expected, actual);
}
private static byte[] RawSerialize(SerialCommand anything)
{
List <byte> Res = new List <byte>();
Res.AddRange(BitConverter.GetBytes(anything.cmd).Take(1));
Res.AddRange(BitConverter.GetBytes(anything.Pipe).Take(8));
Res.AddRange(BitConverter.GetBytes(anything.DataSize).Take(2));
Res.AddRange(BitConverter.GetBytes(anything.TimeOut).Take(4));
Res.AddRange(anything.CryptoKey);
return(Res.ToArray());
}
public Mcu(ConfigWrapper config, ClockSync clocksync)
{
this._printer = config.get_printer();
this._clocksync = clocksync;
this._reactor = _printer.get_reactor();
this._name = config.get_name();
if (this._name.StartsWith("mcu "))
{
this._name = this._name.Substring(4);
}
this._printer.register_event_handler("klippy:connect", this._connect);
this._printer.register_event_handler("klippy:shutdown", this._shutdown);
this._printer.register_event_handler("klippy:disconnect", this._disconnect);
// Serial port
this._serialport = config.get("serial", "/dev/ttyS0");
var baud = 0;
if (!(this._serialport.StartsWith("/dev/rpmsg_") || this._serialport.StartsWith("/tmp/klipper_host_")))
{
baud = (int)config.getint("baud", 250000, minval: 2400);
}
this._serial = new SerialReader(this._reactor, this._serialport, baud);
// Restarts
this._restart_method = RestartMethod.Command;
if (baud != 0)
{
this._restart_method = config.getEnum <RestartMethod>("restart_method", RestartMethod.None);
}
this._reset_cmd = null;
this._emergency_stop_cmd = null;
this._is_shutdown = false;
this._shutdown_msg = "";
// Config building
this._printer.lookup_object <PrinterPins>("pins").register_chip(this._name, this);
this._oid_count = 0;
this._config_callbacks = new List <Action>();
this._init_cmds = new List <string>();
this._config_cmds = new List <string>();
this._pin_map = config.get("pin_map", null);
this._custom = config.get("custom", "");
this._mcu_freq = 0.0;
// Move command queuing
this._max_stepper_error = config.getfloat("max_stepper_error", 2.5E-05, minval: 0.0);
this._move_count = 0;
this._stepqueues = new List <stepcompress>();
this._steppersync = null;
// Stats
this._stats_sumsq_base = 0.0;
this._mcu_tick_avg = 0.0;
this._mcu_tick_stddev = 0.0;
this._mcu_tick_awake = 0.0;
}
public void SendCommandWithResponse(SerialCommand command)
{
if (!serialPort.IsOpen)
{
throw new InvalidOperationException("Serial port is not open");
}
var bytesToWrite = command.GetAllBytes();
var responseBuffer = WriteBytesAndGetResponse(bytesToWrite);
command.ApplyResponseAndVerify(responseBuffer);
}
public void _build_config()
{
if (_is_static)
{
_mcu.add_config_cmd($"set_digital_out pin={_pin} value={(_start_value ? 1 : 0)}");
return;
}
_oid = _mcu.create_oid();
_mcu.add_config_cmd($"config_digital_out oid={_oid} pin={_pin} value={(_start_value ? 1 : 0)} default_value={(_shutdown_value ? 1 : 0)} max_duration={_mcu.seconds_to_clock(_max_duration)}");
var cmd_queue = _mcu.alloc_command_queue();
_set_cmd = _mcu.lookup_command("schedule_digital_out oid=%c clock=%u value=%c", cq: cmd_queue);
}
public void _build_config()
{
var max_error = this._mcu.get_max_stepper_error();
var min_stop_interval = Math.Max(0.0, this._min_stop_interval - max_error);
this._mcu.add_config_cmd($"config_stepper oid={this._oid} step_pin={this._step_pin} dir_pin={this._dir_pin} min_stop_interval={this._mcu.seconds_to_clock(min_stop_interval)} invert_step={(this._invert_step ? 1 : 0)}");
this._mcu.add_config_cmd($"reset_step_clock oid={this._oid} clock=0", is_init: true);
var step_cmd_id = this._mcu.lookup_command_id("queue_step oid=%c interval=%u count=%hu add=%hi");
var dir_cmd_id = this._mcu.lookup_command_id("set_next_step_dir oid=%c dir=%c");
this._reset_cmd_id = this._mcu.lookup_command_id("reset_step_clock oid=%c clock=%u");
this._get_position_cmd = this._mcu.lookup_command("stepper_get_position oid=%c");
this._stepqueue.fill((uint)this._mcu.seconds_to_clock(max_error), this._invert_dir, (uint)step_cmd_id, (uint)dir_cmd_id);
}
void _connect()
{
if (this.is_fileoutput())
{
this._connect_file();
}
else
{
if (this._restart_method == RestartMethod.Rpi_usb && !System.IO.File.Exists(this._serialport))
{
// Try toggling usb power
this._check_restart("enable power");
}
this._serial.Connect();
this._clocksync.connect(this._serial);
}
var msgparser = this._serial.msgparser;
var name = this._name;
var log_info = new List <string> {
$"Loaded MCU '{name}' {msgparser.messages_by_id.Count} commands ({msgparser.version} / {msgparser.build_versions})",
$"MCU '{name}' config: {string.Join(" ", msgparser.config.Select((a) => $"{a.Key}={a.Value}"))}"
};
logging.Info(log_info[0]);
logging.Info(log_info[1]);
this._mcu_freq = this.get_constant_float("CLOCK_FREQ");
this._stats_sumsq_base = this.get_constant_float("STATS_SUMSQ_BASE");
this._emergency_stop_cmd = this.lookup_command("emergency_stop");
this._reset_cmd = this.try_lookup_command("reset");
this._config_reset_cmd = this.try_lookup_command("config_reset");
if (this._restart_method == RestartMethod.None &&
(this._reset_cmd != null || this._config_reset_cmd != null) &&
msgparser.get_constant("SERIAL_BAUD", null) == null)
{
this._restart_method = RestartMethod.Command;
}
this.register_msg(this._handle_shutdown, "shutdown");
this.register_msg(this._handle_shutdown, "is_shutdown");
this.register_msg(this._handle_mcu_stats, "stats");
this._check_config();
var move_msg = $"Configured MCU '{name}' ({this._move_count} moves)";
logging.Info(move_msg);
log_info.Add(move_msg);
this._printer.set_rollover_info(name, string.Join("\n", log_info), log: false);
}
public void _build_config()
{
_oid = _mcu.create_oid();
_mcu.add_config_cmd($"config_end_stop oid={_oid} pin={_pin} pull_up={(_pullup ? 1 : 0)} stepper_count={_steppers.Count}");
_mcu.add_config_cmd($"end_stop_home oid={_oid} clock=0 sample_ticks=0 sample_count=0 rest_ticks=0 pin_value=0", is_init: true);
for (int i = 0; i < _steppers.Count; i++)
{
var s = _steppers[i];
_mcu.add_config_cmd($"end_stop_set_stepper oid={_oid} pos={i} stepper_oid={s.get_oid()}", is_init: true);
}
var cmd_queue = _mcu.alloc_command_queue();
_home_cmd = _mcu.lookup_command("end_stop_home oid=%c clock=%u sample_ticks=%u sample_count=%c rest_ticks=%u pin_value=%c", cq: cmd_queue);
_query_cmd = _mcu.lookup_command("end_stop_query oid=%c", cq: cmd_queue);
_mcu.register_msg(_handle_end_stop_state, "end_stop_state", _oid);
}
public void SendCommandWithAck(SerialCommand command)
{
if (!serialPort.IsOpen)
{
throw new InvalidOperationException("Serial port is not open");
}
var bytesToWrite = command.GetAllBytes();
var response = WriteBytesAndGetResponse(bytesToWrite);
if (response[0] != 0x07 || response[1] != 0xF3)
{
throw new InvalidOperationException("Expected ACK response, got something else");
}
}
public Mcu_pwm(Mcu mcu, PinParams pin_params)
{
_mcu = mcu;
_hardware_pwm = false;
_cycle_time = 0.1;
_max_duration = 2.0;
_oid = 0;
_mcu.register_config_callback(this._build_config);
_pin = pin_params.pin;
_invert = pin_params.invert;
_start_value = this._shutdown_value = pin_params.invert ? 1 : 0;
_is_static = false;
_last_clock = 0;
_pwm_max = 0.0;
_set_cmd = null;
}
public void HandleExceptionOnSendTimeoutTest()
{
mock.Setup(sp => sp.Send(It.Is <string>(s => s.Equals("0"))));
mock.Setup(sp => sp.Read()).Throws(new TimeoutException());
ISerialPort port = mock.Object;
SerialCommand command = new SerialCommand(port);
string response = "";
string expected = "0";
if (command.Send(command.StatusCheck()))
{
response = command.Read();
}
Assert.False(command.ValidateResponse(expected, response));
}
public void SendSuccessfulStatusCheckTest()
{
string expected = "0";
mock.Setup(sp => sp.Send(It.Is <string>(s => s.Equals("0"))));
mock.Setup(sp => sp.Read()).Returns(expected);
ISerialPort port = mock.Object;
SerialCommand command = new SerialCommand(port);
string response = "";
if (command.Send(command.StatusCheck()))
{
response = command.Read();
}
Assert.True(command.ValidateResponse(expected, response));
}
/// <summary>
/// Parses text to known commands
/// </summary>
public PacketSerial(string PayloadString)
{
if (PayloadString == null)
{
return;
}
string[] CommandAndData = PayloadString.Split(System.Convert.ToChar(","));
// Remove Space if exists after command
Command = GetCommand(CommandAndData[0].Trim());
if (CommandAndData.Count() > 1)
{
Data = CommandAndData.ToList();
Data.RemoveAt(0);
}
else
{
Data = null;
}
}
// -------------------------------------------------------------------------------------------------
// Sends a command
//
// \param uart The uart.
// \param sendBytes The send in bytes.
// \param cb The cb.
// \param wantbytes The wantbytes.
// \param tag (Optional) The tag.
// -------------------------------------------------------------------------------------------------
public void SendCommand(UARTCommand uart, byte[] sendBytes, SerialCallback cb, int wantbytes, int tag, int a0, int a1)
{
if (pause)
{
return;
}
if (commands.Count > 50)
{
return;
}
if (!mySerialPort.IsOpen)
{
return;
}
SerialCommand t = new SerialCommand(uart, sendBytes, cb, wantbytes, tag, a0, a1);
commands.Enqueue(t);
}
public static String SendSerialCommand(SerialCommand cmd)
{
System.Diagnostics.Debug.Assert(!String.IsNullOrEmpty(cmd.Command));
System.Diagnostics.Debug.Assert(cmd.SerialPort != 0);
using (SerialPort serialPort = new SerialPort(cmd.SerialPortString, cmd.BaudRate, cmd.Parity, cmd.DataBits, cmd.StopBits))
{
try
{
serialPort.ReadTimeout = 1000;
serialPort.Open();
if (cmd.Hex)
{
byte[] buffer = HexStringToBytes(cmd.Command);
serialPort.Write(buffer, 0, buffer.Length);
}
else
serialPort.WriteLine(cmd.Command + "\r"); // Add a carriage return because most devices want one
string actualResponse = String.Empty;
foreach (char c in cmd.ExpectedResponse)
{
char rcvdChar = (char)serialPort.ReadChar();
actualResponse += rcvdChar;
if (rcvdChar != c)
{
actualResponse += serialPort.ReadExisting();
return actualResponse + "!=" + cmd.ExpectedResponse;
}
}
//System.Threading.Thread.Sleep(cmd.SleepTime);
return actualResponse;
}
finally
{
serialPort.Close();
}
}
}
public Mcu_stepper(Mcu mcu, PinParams pin_parameters)
{
this._mcu = mcu;
this._oid = this._mcu.create_oid();
this._mcu.register_config_callback(this._build_config);
this._step_pin = pin_parameters.pin;
this._invert_step = pin_parameters.invert;
this._dir_pin = null;
this._mcu_position_offset = 0.0;
this._step_dist = 0.0;
this._min_stop_interval = 0.0;
this._reset_cmd_id = 0;
this._get_position_cmd = null;
//var _tup_1 = chelper.get_ffi();
//var ffi_main = _tup_1.Item1;
//this._ffi_lib = _tup_1.Item2;
//this._stepqueue = ffi_main.gc(this._ffi_lib.stepcompress_alloc(this._oid), this._ffi_lib.stepcompress_free);
this._stepqueue = new stepcompress((uint)this._oid);
this._mcu.register_stepqueue(this._stepqueue);
this._stepper_kinematics = null;
this.set_ignore_move(false);
}
public static bool Validate(SerialCommand serialCommand, string commandResponce)
{
if (string.IsNullOrEmpty(commandResponce))
{
return(false);
}
switch (serialCommand)
{
case SerialCommand.STATUS: return("OK".Equals(commandResponce));
case SerialCommand.SEPARATOR: return(commandResponce.Length == 1);
case SerialCommand.PIXELCOUNT:
case SerialCommand.PROGRAMCOUNT:
case SerialCommand.BUFFERSIZE: try {
int value = 0;
int.TryParse(commandResponce, out value);
return(true);
}
catch
{
return(false);
}
/* these are json responces, we could check by try serialize but it takes time */
case SerialCommand.COLORS: return(commandResponce[0] == '[' && commandResponce.EndsWith("]"));
case SerialCommand.PROGRAMINFO:
case SerialCommand.ALLSTATUS:
case SerialCommand.VALUES:
return(commandResponce[0] == '{' && commandResponce.EndsWith("}"));
}
return(false);
}
private void listBoxCommandSequence_DoubleClick(object sender, EventArgs e)
{
if (listBoxMacro.SelectedIndex == -1)
{
return;
}
try
{
string selected = listBoxMacro.SelectedItem as string;
string newCommand = null;
if (selected.StartsWith(IrssUtils.Common.CmdPrefixRun, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitRunCommand(selected.Substring(IrssUtils.Common.CmdPrefixRun.Length));
ExternalProgram executeProgram = new ExternalProgram(commands);
if (executeProgram.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixRun + executeProgram.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixPause, StringComparison.OrdinalIgnoreCase))
{
PauseTime pauseTime = new PauseTime(int.Parse(selected.Substring(IrssUtils.Common.CmdPrefixPause.Length)));
if (pauseTime.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixPause + pauseTime.Time;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixSerial, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitSerialCommand(selected.Substring(IrssUtils.Common.CmdPrefixSerial.Length));
SerialCommand serialCommand = new SerialCommand(commands);
if (serialCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixSerial + serialCommand.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixWindowMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitWindowMessageCommand(selected.Substring(IrssUtils.Common.CmdPrefixWindowMsg.Length));
MessageCommand messageCommand = new MessageCommand(commands);
if (messageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixWindowMsg + messageCommand.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixTcpMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitTcpMessageCommand(selected.Substring(IrssUtils.Common.CmdPrefixTcpMsg.Length));
TcpMessageCommand tcpMessageCommand = new TcpMessageCommand(commands);
if (tcpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixTcpMsg + tcpMessageCommand.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixHttpMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitHttpMessageCommand(selected.Substring(IrssUtils.Common.CmdPrefixHttpMsg.Length));
HttpMessageCommand httpMessageCommand = new HttpMessageCommand(commands);
if (httpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixHttpMsg + httpMessageCommand.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixKeys, StringComparison.OrdinalIgnoreCase))
{
KeysCommand keysCommand = new KeysCommand(selected.Substring(IrssUtils.Common.CmdPrefixKeys.Length));
if (keysCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixKeys + keysCommand.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixMouse, StringComparison.OrdinalIgnoreCase))
{
MouseCommand mouseCommand = new MouseCommand(selected.Substring(IrssUtils.Common.CmdPrefixMouse.Length));
if (mouseCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixMouse + mouseCommand.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixEject, StringComparison.OrdinalIgnoreCase))
{
EjectCommand ejectCommand = new EjectCommand(selected.Substring(IrssUtils.Common.CmdPrefixEject.Length));
if (ejectCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixEject + ejectCommand.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixPopup, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitPopupCommand(selected.Substring(IrssUtils.Common.CmdPrefixPopup.Length));
PopupMessage popupMessage = new PopupMessage(commands);
if (popupMessage.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixPopup + popupMessage.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixGotoScreen, StringComparison.OrdinalIgnoreCase))
{
GoToScreen goToScreen = new GoToScreen(selected.Substring(IrssUtils.Common.CmdPrefixGotoScreen.Length));
if (goToScreen.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixGotoScreen + goToScreen.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixSendMPAction, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitSendMPActionCommand(selected.Substring(IrssUtils.Common.CmdPrefixSendMPAction.Length));
MPAction edit = new MPAction(commands);
if (edit.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixSendMPAction + edit.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixSendMPMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitSendMPMsgCommand(selected.Substring(IrssUtils.Common.CmdPrefixSendMPMsg.Length));
MPMessage edit = new MPMessage(commands);
if (edit.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixSendMPMsg + edit.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixBeep, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitBeepCommand(selected.Substring(IrssUtils.Common.CmdPrefixBeep.Length));
BeepCommand beepCommand = new BeepCommand(commands);
if (beepCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixBeep + beepCommand.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixSound, StringComparison.OrdinalIgnoreCase))
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "Wave Files|*.wav";
openFileDialog.Multiselect = false;
openFileDialog.FileName = selected.Substring(IrssUtils.Common.CmdPrefixSound.Length);
if (openFileDialog.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixSound + openFileDialog.FileName;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixDisplayMode, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitDisplayModeCommand(selected.Substring(IrssUtils.Common.CmdPrefixDisplayMode.Length));
DisplayModeCommand displayModeCommand = new DisplayModeCommand(commands);
if (displayModeCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixDisplayMode + displayModeCommand.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixBlast, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitBlastCommand(selected.Substring(IrssUtils.Common.CmdPrefixBlast.Length));
BlastCommand blastCommand = new BlastCommand(
MPBlastZonePlugin.BlastIR,
IrssUtils.Common.FolderIRCommands,
MPBlastZonePlugin.TransceiverInformation.Ports,
commands);
if (blastCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixBlast + blastCommand.CommandString;
}
}
if (!String.IsNullOrEmpty(newCommand))
{
int index = listBoxMacro.SelectedIndex;
listBoxMacro.Items.RemoveAt(index);
listBoxMacro.Items.Insert(index, newCommand);
listBoxMacro.SelectedIndex = index;
}
}
catch (Exception ex)
{
Log.Error(ex);
MessageBox.Show(this, ex.Message, "Failed to edit macro item", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void buttonAddCommand_Click(object sender, EventArgs e)
{
if (comboBoxCommands.SelectedIndex == -1)
{
return;
}
try
{
string selected = comboBoxCommands.SelectedItem as string;
string newCommand = null;
if (selected.Equals(Common.UITextRun, StringComparison.OrdinalIgnoreCase))
{
ExternalProgram externalProgram = new ExternalProgram();
if (externalProgram.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixRun + externalProgram.CommandString;
}
}
else if (selected.Equals(Common.UITextPause, StringComparison.OrdinalIgnoreCase))
{
PauseTime pauseTime = new PauseTime();
if (pauseTime.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixPause + pauseTime.Time;
}
}
else if (selected.Equals(Common.UITextSerial, StringComparison.OrdinalIgnoreCase))
{
SerialCommand serialCommand = new SerialCommand();
if (serialCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixSerial + serialCommand.CommandString;
}
}
else if (selected.Equals(Common.UITextWindowMsg, StringComparison.OrdinalIgnoreCase))
{
MessageCommand messageCommand = new MessageCommand();
if (messageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixWindowMsg + messageCommand.CommandString;
}
}
else if (selected.Equals(Common.UITextTcpMsg, StringComparison.OrdinalIgnoreCase))
{
TcpMessageCommand tcpMessageCommand = new TcpMessageCommand();
if (tcpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixTcpMsg + tcpMessageCommand.CommandString;
}
}
else if (selected.Equals(Common.UITextHttpMsg, StringComparison.OrdinalIgnoreCase))
{
HttpMessageCommand httpMessageCommand = new HttpMessageCommand();
if (httpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixHttpMsg + httpMessageCommand.CommandString;
}
}
else if (selected.Equals(Common.UITextKeys, StringComparison.OrdinalIgnoreCase))
{
KeysCommand keysCommand = new KeysCommand();
if (keysCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixKeys + keysCommand.CommandString;
}
}
else if (selected.Equals(Common.UITextEject, StringComparison.OrdinalIgnoreCase))
{
EjectCommand ejectCommand = new EjectCommand();
if (ejectCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixEject + ejectCommand.CommandString;
}
}
else if (selected.Equals(Common.UITextStandby, StringComparison.OrdinalIgnoreCase))
{
newCommand = Common.CmdPrefixStandby;
}
else if (selected.Equals(Common.UITextHibernate, StringComparison.OrdinalIgnoreCase))
{
newCommand = Common.CmdPrefixHibernate;
}
else if (selected.Equals(Common.UITextReboot, StringComparison.OrdinalIgnoreCase))
{
newCommand = Common.CmdPrefixReboot;
}
else if (selected.Equals(Common.UITextShutdown, StringComparison.OrdinalIgnoreCase))
{
newCommand = Common.CmdPrefixShutdown;
}
else if (selected.StartsWith(Common.CmdPrefixBlast, StringComparison.OrdinalIgnoreCase))
{
BlastCommand blastCommand = new BlastCommand(
TV3BlasterPlugin.BlastIR,
Common.FolderIRCommands,
TV3BlasterPlugin.TransceiverInformation.Ports,
selected.Substring(Common.CmdPrefixBlast.Length));
if (blastCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixBlast + blastCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixMacro, StringComparison.OrdinalIgnoreCase))
{
newCommand = selected;
}
else
{
throw new CommandStructureException(String.Format("Unknown command in macro command list \"{0}\"", selected));
}
if (!String.IsNullOrEmpty(newCommand))
{
listBoxMacro.Items.Add(newCommand);
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
MessageBox.Show(this, ex.Message, "Failed to add macro command", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public static String SendSerialCommand(String command)
{
SerialCommand cmd = new SerialCommand(1, command);
return SendSerialCommand(cmd);
}
private void buttonSetCommand_Click(object sender, EventArgs e)
{
if (treeViewMenu.SelectedNode == null)
{
return;
}
TreeNode parent = treeViewMenu.SelectedNode;
switch (treeViewMenu.SelectedNode.Level)
{
case 0:
return;
case 1:
parent = treeViewMenu.SelectedNode;
break;
case 2:
parent = treeViewMenu.SelectedNode.Parent;
break;
}
if (comboBoxCommands.SelectedIndex == -1)
{
return;
}
string selected = comboBoxCommands.SelectedItem as string;
string newCommand = null;
if (selected.Equals(IrssUtils.Common.UITextRun, StringComparison.OrdinalIgnoreCase))
{
ExternalProgram externalProgram = new ExternalProgram();
if (externalProgram.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixRun + externalProgram.CommandString;
}
}
else if (selected.Equals(IrssUtils.Common.UITextSerial, StringComparison.OrdinalIgnoreCase))
{
SerialCommand serialCommand = new SerialCommand();
if (serialCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixSerial + serialCommand.CommandString;
}
}
else if (selected.Equals(IrssUtils.Common.UITextWindowMsg, StringComparison.OrdinalIgnoreCase))
{
MessageCommand messageCommand = new MessageCommand();
if (messageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixWindowMsg + messageCommand.CommandString;
}
}
else if (selected.Equals(IrssUtils.Common.UITextTcpMsg, StringComparison.OrdinalIgnoreCase))
{
TcpMessageCommand tcpMessageCommand = new TcpMessageCommand();
if (tcpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixTcpMsg + tcpMessageCommand.CommandString;
}
}
else if (selected.Equals(IrssUtils.Common.UITextEject, StringComparison.OrdinalIgnoreCase))
{
EjectCommand ejectCommand = new EjectCommand();
if (ejectCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixEject + ejectCommand.CommandString;
}
}
else if (selected.Equals(IrssUtils.Common.UITextGotoScreen, StringComparison.OrdinalIgnoreCase))
{
GoToScreen goToScreen = new GoToScreen();
if (goToScreen.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixGotoScreen + goToScreen.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixBlast, StringComparison.OrdinalIgnoreCase))
{
BlastCommand blastCommand = new BlastCommand(
MPBlastZonePlugin.BlastIR,
IrssUtils.Common.FolderIRCommands,
MPBlastZonePlugin.TransceiverInformation.Ports,
selected.Substring(IrssUtils.Common.CmdPrefixBlast.Length));
if (blastCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixBlast + blastCommand.CommandString;
}
}
else
{
newCommand = selected;
}
parent.Nodes.Clear();
TreeNode newNode = new TreeNode(newCommand);
newNode.ForeColor = Color.Blue;
parent.Nodes.Add(newNode);
newNode.EnsureVisible();
}
private void listBoxCommandSequence_DoubleClick(object sender, EventArgs e)
{
if (listBoxMacro.SelectedIndex == -1)
{
return;
}
try
{
string selected = listBoxMacro.SelectedItem as string;
string newCommand = null;
if (selected.StartsWith(Common.CmdPrefixRun, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitRunCommand(selected.Substring(Common.CmdPrefixRun.Length));
ExternalProgram executeProgram = new ExternalProgram(commands);
if (executeProgram.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixRun + executeProgram.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixPause, StringComparison.OrdinalIgnoreCase))
{
PauseTime pauseTime = new PauseTime(int.Parse(selected.Substring(Common.CmdPrefixPause.Length)));
if (pauseTime.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixPause + pauseTime.Time;
}
}
else if (selected.StartsWith(Common.CmdPrefixSerial, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitSerialCommand(selected.Substring(Common.CmdPrefixSerial.Length));
SerialCommand serialCommand = new SerialCommand(commands);
if (serialCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixSerial + serialCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixWindowMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitWindowMessageCommand(selected.Substring(Common.CmdPrefixWindowMsg.Length));
MessageCommand messageCommand = new MessageCommand(commands);
if (messageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixWindowMsg + messageCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixTcpMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitTcpMessageCommand(selected.Substring(Common.CmdPrefixTcpMsg.Length));
TcpMessageCommand tcpMessageCommand = new TcpMessageCommand(commands);
if (tcpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixTcpMsg + tcpMessageCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixHttpMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitHttpMessageCommand(selected.Substring(Common.CmdPrefixHttpMsg.Length));
HttpMessageCommand httpMessageCommand = new HttpMessageCommand(commands);
if (httpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixHttpMsg + httpMessageCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixKeys, StringComparison.OrdinalIgnoreCase))
{
KeysCommand keysCommand = new KeysCommand(selected.Substring(Common.CmdPrefixKeys.Length));
if (keysCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixKeys + keysCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixMouse, StringComparison.OrdinalIgnoreCase))
{
MouseCommand mouseCommand = new MouseCommand(selected.Substring(Common.CmdPrefixMouse.Length));
if (mouseCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixMouse + mouseCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixEject, StringComparison.OrdinalIgnoreCase))
{
EjectCommand ejectCommand = new EjectCommand(selected.Substring(Common.CmdPrefixEject.Length));
if (ejectCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixEject + ejectCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixBlast, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitBlastCommand(selected.Substring(Common.CmdPrefixBlast.Length));
BlastCommand blastCommand = new BlastCommand(
TV3BlasterPlugin.BlastIR,
Common.FolderIRCommands,
TV3BlasterPlugin.TransceiverInformation.Ports,
commands);
if (blastCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixBlast + blastCommand.CommandString;
}
}
if (!String.IsNullOrEmpty(newCommand))
{
int index = listBoxMacro.SelectedIndex;
listBoxMacro.Items.RemoveAt(index);
listBoxMacro.Items.Insert(index, newCommand);
listBoxMacro.SelectedIndex = index;
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
MessageBox.Show(this, ex.Message, "Failed to edit macro item", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void buttonSet_Click(object sender, EventArgs e)
{
if (listViewExternalCommands.SelectedIndices.Count == 0 || comboBoxCommands.SelectedIndex == -1)
{
return;
}
try
{
string selected = comboBoxCommands.SelectedItem as string;
string newCommand = null;
if (selected.Equals(Common.UITextRun, StringComparison.OrdinalIgnoreCase))
{
ExternalProgram externalProgram = new ExternalProgram(ParameterInfo);
if (externalProgram.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixRun + externalProgram.CommandString;
}
}
else if (selected.Equals(Common.UITextSerial, StringComparison.OrdinalIgnoreCase))
{
SerialCommand serialCommand = new SerialCommand(ParameterInfo);
if (serialCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixSerial + serialCommand.CommandString;
}
}
else if (selected.Equals(Common.UITextWindowMsg, StringComparison.OrdinalIgnoreCase))
{
MessageCommand messageCommand = new MessageCommand();
if (messageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixWindowMsg + messageCommand.CommandString;
}
}
else if (selected.Equals(Common.UITextTcpMsg, StringComparison.OrdinalIgnoreCase))
{
TcpMessageCommand tcpMessageCommand = new TcpMessageCommand();
if (tcpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixTcpMsg + tcpMessageCommand.CommandString;
}
}
else if (selected.Equals(Common.UITextHttpMsg, StringComparison.OrdinalIgnoreCase))
{
HttpMessageCommand httpMessageCommand = new HttpMessageCommand();
if (httpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixHttpMsg + httpMessageCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixBlast, StringComparison.OrdinalIgnoreCase))
{
BlastCommand blastCommand = new BlastCommand(
TV3BlasterPlugin.BlastIR,
Common.FolderIRCommands,
TV3BlasterPlugin.TransceiverInformation.Ports,
selected.Substring(Common.CmdPrefixBlast.Length));
if (blastCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixBlast + blastCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixMacro, StringComparison.OrdinalIgnoreCase))
{
newCommand = selected;
}
else
{
throw new CommandStructureException(String.Format("Invalid command in STB Setup: {0}", selected));
}
if (!String.IsNullOrEmpty(newCommand))
{
foreach (ListViewItem item in listViewExternalCommands.SelectedItems)
{
item.SubItems[1].Text = newCommand;
}
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
MessageBox.Show(this, ex.Message, "Failed to set command", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void listViewExternalCommands_DoubleClick(object sender, EventArgs e)
{
if (listViewExternalCommands.SelectedIndices.Count != 1)
{
return;
}
try
{
string selected = listViewExternalCommands.SelectedItems[0].SubItems[1].Text;
string newCommand = null;
if (selected.StartsWith(Common.CmdPrefixBlast, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitBlastCommand(selected.Substring(Common.CmdPrefixBlast.Length));
BlastCommand blastCommand = new BlastCommand(
TV3BlasterPlugin.BlastIR,
Common.FolderIRCommands,
TV3BlasterPlugin.TransceiverInformation.Ports,
commands);
if (blastCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixBlast + blastCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixSTB, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitBlastCommand(selected.Substring(Common.CmdPrefixSTB.Length));
BlastCommand blastCommand = new BlastCommand(
TV3BlasterPlugin.BlastIR,
Common.FolderSTB,
TV3BlasterPlugin.TransceiverInformation.Ports,
commands);
if (blastCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixSTB + blastCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixRun, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitRunCommand(selected.Substring(Common.CmdPrefixRun.Length));
ExternalProgram executeProgram = new ExternalProgram(commands, ParameterInfo);
if (executeProgram.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixRun + executeProgram.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixSerial, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitSerialCommand(selected.Substring(Common.CmdPrefixSerial.Length));
SerialCommand serialCommand = new SerialCommand(commands, ParameterInfo);
if (serialCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixSerial + serialCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixWindowMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitWindowMessageCommand(selected.Substring(Common.CmdPrefixWindowMsg.Length));
MessageCommand messageCommand = new MessageCommand(commands);
if (messageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixWindowMsg + messageCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixTcpMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitTcpMessageCommand(selected.Substring(Common.CmdPrefixTcpMsg.Length));
TcpMessageCommand tcpMessageCommand = new TcpMessageCommand(commands);
if (tcpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixTcpMsg + tcpMessageCommand.CommandString;
}
}
else if (selected.StartsWith(Common.CmdPrefixHttpMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = Common.SplitHttpMessageCommand(selected.Substring(Common.CmdPrefixHttpMsg.Length));
HttpMessageCommand httpMessageCommand = new HttpMessageCommand(commands);
if (httpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = Common.CmdPrefixHttpMsg + httpMessageCommand.CommandString;
}
}
if (!String.IsNullOrEmpty(newCommand))
{
listViewExternalCommands.SelectedItems[0].SubItems[1].Text = newCommand;
}
}
catch (Exception ex)
{
Log.Error(ex.ToString());
MessageBox.Show(this, ex.Message, "Failed to edit command", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void buttonSetCommand_Click(object sender, EventArgs e)
{
if (comboBoxCommands.SelectedIndex == -1)
{
return;
}
string selected = comboBoxCommands.SelectedItem as string;
string newCommand = null;
if (selected.Equals(IrssUtils.Common.UITextRun, StringComparison.OrdinalIgnoreCase))
{
ExternalProgram externalProgram = new ExternalProgram();
if (externalProgram.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixRun + externalProgram.CommandString;
}
}
else if (selected.Equals(IrssUtils.Common.UITextSerial, StringComparison.OrdinalIgnoreCase))
{
SerialCommand serialCommand = new SerialCommand();
if (serialCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixSerial + serialCommand.CommandString;
}
}
else if (selected.Equals(IrssUtils.Common.UITextWindowMsg, StringComparison.OrdinalIgnoreCase))
{
MessageCommand messageCommand = new MessageCommand();
if (messageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixWindowMsg + messageCommand.CommandString;
}
}
else if (selected.Equals(IrssUtils.Common.UITextTcpMsg, StringComparison.OrdinalIgnoreCase))
{
TcpMessageCommand tcpMessageCommand = new TcpMessageCommand();
if (tcpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixTcpMsg + tcpMessageCommand.CommandString;
}
}
else if (selected.Equals(IrssUtils.Common.UITextKeys, StringComparison.OrdinalIgnoreCase))
{
KeysCommand keysCommand = new KeysCommand();
if (keysCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixKeys + keysCommand.CommandString;
}
}
else if (selected.Equals(IrssUtils.Common.UITextEject, StringComparison.OrdinalIgnoreCase))
{
EjectCommand ejectCommand = new EjectCommand();
if (ejectCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixEject + ejectCommand.CommandString;
}
}
else if (selected.Equals(IrssUtils.Common.UITextGotoScreen, StringComparison.OrdinalIgnoreCase))
{
GoToScreen goToScreen = new GoToScreen();
if (goToScreen.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixGotoScreen + goToScreen.CommandString;
}
}
else if (selected.StartsWith(IrssUtils.Common.CmdPrefixBlast, StringComparison.OrdinalIgnoreCase))
{
BlastCommand blastCommand = new BlastCommand(
MPControlPlugin.BlastIR,
IrssUtils.Common.FolderIRCommands,
MPControlPlugin.TransceiverInformation.Ports,
selected.Substring(IrssUtils.Common.CmdPrefixBlast.Length));
if (blastCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixBlast + blastCommand.CommandString;
}
}
else
{
newCommand = selected;
}
foreach (ListViewItem listViewItem in listViewEventMap.SelectedItems)
{
listViewItem.SubItems[1].Text = newCommand;
}
}
private void listViewEventMap_DoubleClick(object sender, EventArgs e)
{
if (listViewEventMap.SelectedItems.Count != 1)
{
return;
}
string command = listViewEventMap.SelectedItems[0].SubItems[1].Text;
string newCommand = null;
if (command.StartsWith(IrssUtils.Common.CmdPrefixRun, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitRunCommand(command.Substring(IrssUtils.Common.CmdPrefixRun.Length));
ExternalProgram externalProgram = new ExternalProgram(commands);
if (externalProgram.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixRun + externalProgram.CommandString;
}
}
else if (command.StartsWith(IrssUtils.Common.CmdPrefixGotoScreen, StringComparison.OrdinalIgnoreCase))
{
GoToScreen goToScreen = new GoToScreen(command.Substring(IrssUtils.Common.CmdPrefixGotoScreen.Length));
if (goToScreen.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixGotoScreen + goToScreen.CommandString;
}
}
else if (command.StartsWith(IrssUtils.Common.CmdPrefixSerial, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitSerialCommand(command.Substring(IrssUtils.Common.CmdPrefixSerial.Length));
SerialCommand serialCommand = new SerialCommand(commands);
if (serialCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixSerial + serialCommand.CommandString;
}
}
else if (command.StartsWith(IrssUtils.Common.CmdPrefixWindowMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitWindowMessageCommand(command.Substring(IrssUtils.Common.CmdPrefixWindowMsg.Length));
MessageCommand messageCommand = new MessageCommand(commands);
if (messageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixWindowMsg + messageCommand.CommandString;
}
}
else if (command.StartsWith(IrssUtils.Common.CmdPrefixKeys, StringComparison.OrdinalIgnoreCase))
{
KeysCommand keysCommand = new KeysCommand(command.Substring(IrssUtils.Common.CmdPrefixKeys.Length));
if (keysCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixKeys + keysCommand.CommandString;
}
}
else if (command.StartsWith(IrssUtils.Common.CmdPrefixBlast, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitBlastCommand(command.Substring(IrssUtils.Common.CmdPrefixBlast.Length));
BlastCommand blastCommand = new BlastCommand(
MPControlPlugin.BlastIR,
IrssUtils.Common.FolderIRCommands,
MPControlPlugin.TransceiverInformation.Ports,
commands);
if (blastCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixBlast + blastCommand.CommandString;
}
}
if (!String.IsNullOrEmpty(newCommand))
{
listViewEventMap.SelectedItems[0].SubItems[1].Text = newCommand;
}
}
private void treeViewMenu_DoubleClick(object sender, EventArgs e)
{
if (treeViewMenu.SelectedNode == null)
{
return;
}
if (treeViewMenu.SelectedNode.Level != 2)
{
return;
}
string command = treeViewMenu.SelectedNode.Text;
string newCommand = null;
if (command.StartsWith(IrssUtils.Common.CmdPrefixRun, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitRunCommand(command.Substring(IrssUtils.Common.CmdPrefixRun.Length));
ExternalProgram externalProgram = new ExternalProgram(commands);
if (externalProgram.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixRun + externalProgram.CommandString;
}
}
else if (command.StartsWith(IrssUtils.Common.CmdPrefixGotoScreen, StringComparison.OrdinalIgnoreCase))
{
GoToScreen goToScreen = new GoToScreen(command.Substring(IrssUtils.Common.CmdPrefixGotoScreen.Length));
if (goToScreen.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixGotoScreen + goToScreen.CommandString;
}
}
else if (command.StartsWith(IrssUtils.Common.CmdPrefixSerial, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitSerialCommand(command.Substring(IrssUtils.Common.CmdPrefixSerial.Length));
SerialCommand serialCommand = new SerialCommand(commands);
if (serialCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixSerial + serialCommand.CommandString;
}
}
else if (command.StartsWith(IrssUtils.Common.CmdPrefixWindowMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitWindowMessageCommand(command.Substring(IrssUtils.Common.CmdPrefixWindowMsg.Length));
MessageCommand messageCommand = new MessageCommand(commands);
if (messageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixWindowMsg + messageCommand.CommandString;
}
}
else if (command.StartsWith(IrssUtils.Common.CmdPrefixTcpMsg, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitTcpMessageCommand(command.Substring(IrssUtils.Common.CmdPrefixTcpMsg.Length));
TcpMessageCommand tcpMessageCommand = new TcpMessageCommand(commands);
if (tcpMessageCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixTcpMsg + tcpMessageCommand.CommandString;
}
}
else if (command.StartsWith(IrssUtils.Common.CmdPrefixBlast, StringComparison.OrdinalIgnoreCase))
{
string[] commands = IrssUtils.Common.SplitBlastCommand(command.Substring(IrssUtils.Common.CmdPrefixBlast.Length));
BlastCommand blastCommand = new BlastCommand(
MPBlastZonePlugin.BlastIR,
IrssUtils.Common.FolderIRCommands,
MPBlastZonePlugin.TransceiverInformation.Ports,
commands);
if (blastCommand.ShowDialog(this) == DialogResult.OK)
{
newCommand = IrssUtils.Common.CmdPrefixBlast + blastCommand.CommandString;
}
}
if (!String.IsNullOrEmpty(newCommand))
{
treeViewMenu.SelectedNode.Text = newCommand;
}
}
