private static (Mock <IChatClient> chatClient, Mock <IRepository> repository, Mock <IAnimationDisplayNotification> display, BlastCommand command) GetTestCommandAndMocks()
        {
            var chatClient          = new Mock <IChatClient>();
            var repository          = new Mock <IRepository>();
            var displayNotification = new Mock <IAnimationDisplayNotification>();
            var blastCommand        = new BlastCommand(repository.Object, displayNotification.Object);

            return(chatClient, repository, displayNotification, blastCommand);
        }
Exemple #2
0
        private static (Mock <IChatClient> chatClient, Mock <IRepository> repository, Mock <IAnimationDisplayNotification> display, BlastCommand command) GetTestCommandAndMocks()
        {
            var chatClient = new Mock <IChatClient>();
            var repository = new Mock <IRepository>();

            repository.Setup(x => x.Single(It.IsAny <CommandPolicy>()))
            .Returns(new CommandEntity {
                HelpText = "The {0}"
            });

            var displayNotification = new Mock <IAnimationDisplayNotification>();
            var blastCommand        = new BlastCommand(repository.Object, displayNotification.Object);

            return(chatClient, repository, displayNotification, blastCommand);
        }
Exemple #3
0
        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);
            }
        }
Exemple #4
0
        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);
            }
        }
Exemple #5
0
        public void SetToXml(string xmlFile)
        {
            if (xmlFile.Equals("Clear all", StringComparison.OrdinalIgnoreCase))
            {
                foreach (ListViewItem item in listViewExternalCommands.Items)
                {
                    item.SubItems[1].Text = String.Empty;
                }

                return;
            }

            string fileName = Path.Combine(Common.FolderSTB, xmlFile + ".xml");

            XmlDocument doc = new XmlDocument();

            doc.Load(fileName);

            XmlNodeList nodeList = doc.DocumentElement.ChildNodes;

            string       command;
            BlastCommand blastCommand;

            bool   useForAllBlastCommands = false;
            string useForAllBlasterPort   = String.Empty;

            int blastCommandCount = 0;

            for (int i = 0; i < 12; i++)
            {
                if (i == 10)
                {
                    command = XML.GetString(nodeList, "SelectCommand", String.Empty);
                }
                else if (i == 11)
                {
                    command = XML.GetString(nodeList, "PreChangeCommand", String.Empty);
                }
                else
                {
                    command = XML.GetString(nodeList, String.Format("Digit{0}", i), String.Empty);
                }

                if (command.StartsWith(Common.CmdPrefixSTB, StringComparison.OrdinalIgnoreCase))
                {
                    blastCommandCount++;
                }
            }

            for (int i = 0; i < 12; i++)
            {
                if (i == 10)
                {
                    command = XML.GetString(nodeList, "SelectCommand", String.Empty);
                }
                else if (i == 11)
                {
                    command = XML.GetString(nodeList, "PreChangeCommand", String.Empty);
                }
                else
                {
                    command = XML.GetString(nodeList, String.Format("Digit{0}", i), String.Empty);
                }

                if (command.StartsWith(Common.CmdPrefixSTB, StringComparison.OrdinalIgnoreCase))
                {
                    blastCommand = new BlastCommand(
                        TV3BlasterPlugin.BlastIR,
                        Common.FolderSTB,
                        TV3BlasterPlugin.TransceiverInformation.Ports,
                        command.Substring(Common.CmdPrefixSTB.Length),
                        blastCommandCount--);

                    if (useForAllBlastCommands)
                    {
                        blastCommand.BlasterPort = useForAllBlasterPort;
                        listViewExternalCommands.Items[i].SubItems[1].Text = Common.CmdPrefixSTB + blastCommand.CommandString;
                    }
                    else
                    {
                        if (blastCommand.ShowDialog(this) == DialogResult.OK)
                        {
                            if (blastCommand.UseForAll)
                            {
                                useForAllBlastCommands = true;
                                useForAllBlasterPort   = blastCommand.BlasterPort;
                            }
                            listViewExternalCommands.Items[i].SubItems[1].Text = Common.CmdPrefixSTB + blastCommand.CommandString;
                        }
                        else
                        {
                            blastCommand = new BlastCommand(
                                TV3BlasterPlugin.BlastIR,
                                Common.FolderSTB,
                                TV3BlasterPlugin.TransceiverInformation.Ports,
                                command.Substring(Common.CmdPrefixSTB.Length));

                            listViewExternalCommands.Items[i].SubItems[1].Text = Common.CmdPrefixSTB + blastCommand.CommandString;
                        }
                    }
                }
                else
                {
                    listViewExternalCommands.Items[i].SubItems[1].Text = command;
                }
            }

            numericUpDownPauseTime.Value =
                new Decimal(XML.GetInt(nodeList, "PauseTime", Decimal.ToInt32(numericUpDownPauseTime.Value)));
            checkBoxUsePreChange.Checked = XML.GetBool(nodeList, "UsePreChangeCommand", checkBoxUsePreChange.Checked);
            checkBoxSendSelect.Checked   = XML.GetBool(nodeList, "SendSelect", checkBoxSendSelect.Checked);
            checkBoxDoubleSelect.Checked = XML.GetBool(nodeList, "DoubleChannelSelect", checkBoxDoubleSelect.Checked);
            numericUpDownRepeat.Value    =
                new Decimal(XML.GetInt(nodeList, "RepeatChannelCommands", Decimal.ToInt32(numericUpDownRepeat.Value)));
            numericUpDownRepeatDelay.Value =
                new Decimal(XML.GetInt(nodeList, "RepeatDelay", Decimal.ToInt32(numericUpDownRepeatDelay.Value)));

            int digitsWas = comboBoxChDigits.SelectedIndex;

            if (digitsWas > 0)
            {
                digitsWas--;
            }
            int digits = XML.GetInt(nodeList, "ChannelDigits", digitsWas);

            if (digits > 0)
            {
                digits++;
            }
            comboBoxChDigits.SelectedIndex = digits;
        }
Exemple #6
0
        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;
            }
        }
Exemple #7
0
        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;
            }
        }
Exemple #8
0
        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;
            }
        }
Exemple #9
0
        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 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);
            }
        }
Exemple #12
0
        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);
            }
        }
Exemple #13
0
        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(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.UITextPause, StringComparison.OrdinalIgnoreCase))
                {
                    PauseTime pauseTime = new PauseTime();
                    if (pauseTime.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = IrssUtils.Common.CmdPrefixPause + pauseTime.Time;
                    }
                }
                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.UITextHttpMsg, StringComparison.OrdinalIgnoreCase))
                {
                    HttpMessageCommand httpMessageCommand = new HttpMessageCommand();
                    if (httpMessageCommand.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = IrssUtils.Common.CmdPrefixHttpMsg + httpMessageCommand.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.UITextMouse, StringComparison.OrdinalIgnoreCase))
                {
                    MouseCommand mouseCommand = new MouseCommand();
                    if (mouseCommand.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = IrssUtils.Common.CmdPrefixMouse + mouseCommand.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.UITextPopup, StringComparison.OrdinalIgnoreCase))
                {
                    PopupMessage popupMessage = new PopupMessage();
                    if (popupMessage.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = IrssUtils.Common.CmdPrefixPopup + popupMessage.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.Equals(IrssUtils.Common.UITextWindowState, StringComparison.OrdinalIgnoreCase))
                 * {
                 * newCommand = IrssUtils.Common.CmdPrefixWindowState;
                 * }
                 */
                else if (selected.Equals(IrssUtils.Common.UITextFocus, StringComparison.OrdinalIgnoreCase))
                {
                    newCommand = IrssUtils.Common.CmdPrefixFocus;
                }
                else if (selected.Equals(IrssUtils.Common.UITextExit, StringComparison.OrdinalIgnoreCase))
                {
                    newCommand = IrssUtils.Common.CmdPrefixExit;
                }
                else if (selected.Equals(IrssUtils.Common.UITextSendMPAction, StringComparison.OrdinalIgnoreCase))
                {
                    MPAction edit = new MPAction();
                    if (edit.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = IrssUtils.Common.CmdPrefixSendMPAction + edit.CommandString;
                    }
                }
                else if (selected.Equals(IrssUtils.Common.UITextSendMPMsg, StringComparison.OrdinalIgnoreCase))
                {
                    MPMessage edit = new MPMessage();
                    if (edit.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = IrssUtils.Common.CmdPrefixSendMPMsg + edit.CommandString;
                    }
                }
                else if (selected.Equals(IrssUtils.Common.UITextVirtualKB, StringComparison.OrdinalIgnoreCase))
                {
                    newCommand = IrssUtils.Common.CmdPrefixVirtualKB;
                }
                else if (selected.Equals(IrssUtils.Common.UITextSmsKB, StringComparison.OrdinalIgnoreCase))
                {
                    newCommand = IrssUtils.Common.CmdPrefixSmsKB;
                }
                else if (selected.Equals(IrssUtils.Common.UITextBeep, StringComparison.OrdinalIgnoreCase))
                {
                    BeepCommand beepCommand = new BeepCommand();
                    if (beepCommand.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = IrssUtils.Common.CmdPrefixBeep + beepCommand.CommandString;
                    }
                }
                else if (selected.Equals(IrssUtils.Common.UITextSound, StringComparison.OrdinalIgnoreCase))
                {
                    OpenFileDialog openFileDialog = new OpenFileDialog();
                    openFileDialog.Filter      = "Wave Files|*.wav";
                    openFileDialog.Multiselect = false;

                    if (openFileDialog.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = IrssUtils.Common.CmdPrefixSound + openFileDialog.FileName;
                    }
                }
                else if (selected.Equals(IrssUtils.Common.UITextDisplayMode, StringComparison.OrdinalIgnoreCase))
                {
                    DisplayModeCommand displayModeCommand = new DisplayModeCommand();
                    if (displayModeCommand.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = IrssUtils.Common.CmdPrefixDisplayMode + displayModeCommand.CommandString;
                    }
                }
                else if (selected.Equals(IrssUtils.Common.UITextStandby, StringComparison.OrdinalIgnoreCase))
                {
                    newCommand = IrssUtils.Common.CmdPrefixStandby;
                }
                else if (selected.Equals(IrssUtils.Common.UITextHibernate, StringComparison.OrdinalIgnoreCase))
                {
                    newCommand = IrssUtils.Common.CmdPrefixHibernate;
                }
                else if (selected.Equals(IrssUtils.Common.UITextReboot, StringComparison.OrdinalIgnoreCase))
                {
                    newCommand = IrssUtils.Common.CmdPrefixReboot;
                }
                else if (selected.Equals(IrssUtils.Common.UITextShutdown, StringComparison.OrdinalIgnoreCase))
                {
                    newCommand = IrssUtils.Common.CmdPrefixShutdown;
                }
                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 if (selected.StartsWith(IrssUtils.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);
                MessageBox.Show(this, ex.Message, "Failed to add macro command", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
Exemple #14
0
        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.UITextIf, StringComparison.OrdinalIgnoreCase))
                {
                    IfCommand ifCommand = new IfCommand();
                    if (ifCommand.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = Common.CmdPrefixIf + ifCommand.CommandString;
                    }
                }
                else if (selected.Equals(Common.UITextLabel, StringComparison.OrdinalIgnoreCase))
                {
                    LabelNameDialog labelDialog = new LabelNameDialog();
                    if (labelDialog.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = Common.CmdPrefixLabel + labelDialog.LabelName;
                    }
                }
                else if (selected.Equals(Common.UITextGotoLabel, StringComparison.OrdinalIgnoreCase))
                {
                    LabelNameDialog labelDialog = new LabelNameDialog();
                    if (labelDialog.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = Common.CmdPrefixGotoLabel + labelDialog.LabelName;
                    }
                }
                else if (selected.Equals(Common.UITextSetVar, StringComparison.OrdinalIgnoreCase))
                {
                    SetVariableCommand setVariableCommand = new SetVariableCommand();
                    if (setVariableCommand.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = Common.CmdPrefixSetVar + setVariableCommand.CommandString;
                    }
                }
                else if (selected.Equals(Common.UITextClearVars, StringComparison.OrdinalIgnoreCase))
                {
                    newCommand = Common.CmdPrefixClearVars;
                }
                else if (selected.Equals(Common.UITextLoadVars, StringComparison.OrdinalIgnoreCase))
                {
                    VariablesFileDialog varsFileDialog = new VariablesFileDialog();
                    if (varsFileDialog.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = Common.CmdPrefixLoadVars + varsFileDialog.FileName;
                    }
                }
                else if (selected.Equals(Common.UITextSaveVars, StringComparison.OrdinalIgnoreCase))
                {
                    VariablesFileDialog varsFileDialog = new VariablesFileDialog();
                    if (varsFileDialog.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = Common.CmdPrefixSaveVars + varsFileDialog.FileName;
                    }
                }
                else 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.UITextMouse, StringComparison.OrdinalIgnoreCase))
                {
                    MouseCommand mouseCommand = new MouseCommand();
                    if (mouseCommand.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = Common.CmdPrefixMouse + mouseCommand.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.UITextPopup, StringComparison.OrdinalIgnoreCase))
                {
                    PopupMessage popupMessage = new PopupMessage();
                    if (popupMessage.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = Common.CmdPrefixPopup + popupMessage.CommandString;
                    }
                }
                else if (selected.Equals(Common.UITextVirtualKB, StringComparison.OrdinalIgnoreCase))
                {
                    newCommand = Common.CmdPrefixVirtualKB;
                }
                else if (selected.Equals(Common.UITextSmsKB, StringComparison.OrdinalIgnoreCase))
                {
                    newCommand = Common.CmdPrefixSmsKB;
                }
                else if (selected.Equals(Common.UITextBeep, StringComparison.OrdinalIgnoreCase))
                {
                    BeepCommand beepCommand = new BeepCommand();
                    if (beepCommand.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = Common.CmdPrefixBeep + beepCommand.CommandString;
                    }
                }
                else if (selected.Equals(Common.UITextSound, StringComparison.OrdinalIgnoreCase))
                {
                    OpenFileDialog openFileDialog = new OpenFileDialog();
                    openFileDialog.Filter      = "Wave Files|*.wav";
                    openFileDialog.Multiselect = false;

                    if (openFileDialog.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = Common.CmdPrefixSound + openFileDialog.FileName;
                    }
                }
                else if (selected.Equals(Common.UITextDisplayMode, StringComparison.OrdinalIgnoreCase))
                {
                    DisplayModeCommand displayModeCommand = new DisplayModeCommand();
                    if (displayModeCommand.ShowDialog(this) == DialogResult.OK)
                    {
                        newCommand = Common.CmdPrefixDisplayMode + displayModeCommand.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(
                        Program.BlastIR,
                        Common.FolderIRCommands,
                        Program.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 macro command ({0})", selected));
                }

                if (!String.IsNullOrEmpty(newCommand))
                {
                    listBoxMacro.Items.Add(newCommand);
                }
            }
            catch (Exception ex)
            {
                IrssLog.Error(ex);
                MessageBox.Show(this, ex.Message, "Failed to add macro command", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }