예제 #1
0
        /// <summary>
        /// Send Data to the Connected Serial Port
        /// </summary>
        /// <param name="message"></param>
        private void ConnectionInterface_SendMsgData(MsgData msg)
        {
            // If the Message is empty we do not send anything
            if (msg.value == null)
            {
                return;
            }

            // Send the Data
            try
            {
                msg.connectionNumber = connectionSelectionSendData;
                if (connection.Send(msg) == 1)
                {
                    // Everything is fine
                }
            }
            catch
            {
                // Configure the message box to be displayed
                string           messageBoxText = "Der Senden Job konnte nicht bearbeitet werden. Das Telegramm ist ungültig!";
                string           caption        = "Ungültige parameter für das Senden";
                MessageBoxButton button         = MessageBoxButton.OK;
                MessageBoxImage  icon           = MessageBoxImage.Warning;

                // Display message box
                MessageBox.Show(messageBoxText, caption, button, icon);
            }
        }
예제 #2
0
        /// <summary>
        /// View Binary Values of the In and Outgoing Data
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void menuItem_ViewRepresentationChange_Click(object sender, RoutedEventArgs e)
        {
            MenuItem menuItemSender = sender as MenuItem;

            // Save the current SendBox Data with the Current View Settings
            try
            {
                currentSendData = msgLog.getRawMsgWithCurrentViewSettings(tbSendData.Text);
            }
            catch
            {
                currentSendData = msgLog.getRawMsgWithCurrentViewSettings("");
            }

            // Set the Current View Configuration
            try
            {
                settings.viewSettings.dataPresentation = (Int32)menuItemSender.Resources["ViewRepresentation"];
            }
            catch
            {
                settings.viewSettings.dataPresentation = 0;
            }


            msgLog.viewSettings = settings.viewSettings;

            // Update the StatusBar
            UpdateViewStateDependence(msgLog.viewSettings);
        }
예제 #3
0
        /// <summary>
        /// Send Data over Serial Interface
        /// </summary>
        /// <param name="data"></param>
        public void send(MsgData message)
        {
            if (pcSerialPort.IsOpen)
            {
                try
                {
                    // Send the Data over Serial and to the UI
                    pcSerialPort.Write(message.value, 0, message.value.Length);// Send the Data after replacing the Human Readable ASCII Chars


                    message.setCurrentTimeStamp();              // Set the Time Stamp
                    message.connectionNumber = interfaceNumber; // Set the Interface Reference

                    // Set the Event that the User Changed an Input
                    MsgSendRecivedEventArgs msgLogEventArgs = new MsgSendRecivedEventArgs();
                    msgLogEventArgs.msgData = message;
                    msgSendRecived(msgLogEventArgs);
                }
                catch (Exception ex)
                {
                    MsgData logMessage = new MsgData();

                    // Set an error Message to the UI
                    logMessage.value = Encoding.ASCII.GetBytes("Konnte nicht gesendet werden: " + message.value + "\n" + ex);
                    logMessage.type  = MsgData.messageType.infoNegative;

                    // Set the Event that the User Changed an Input
                    MsgSendRecivedEventArgs msgLogEventArgs = new MsgSendRecivedEventArgs();
                    msgLogEventArgs.msgData = message;
                    msgSendRecived(msgLogEventArgs);
                }
            }
        }
예제 #4
0
        /// <summary>
        /// Returns the previous MSG in the Send History
        /// </summary>
        /// <returns></returns>
        public string getPriviousSendedMsg()
        {
            // Check if the History allready exist
            if (sendHistory.Count == 0)
            {
                return("");
            }


            MsgData sendMsgHistoryItem = new MsgData();

            // Increment the Index of the History List
            if (sendMsgHistoryCurrentIndex >= sendHistory.Count - 1)
            {
                sendMsgHistoryCurrentIndex = 0;
            }
            else
            {
                sendMsgHistoryCurrentIndex++;
            }

            sendMsgHistoryItem = sendHistory.ElementAt(sendMsgHistoryCurrentIndex);


            return(getMsgWithCurrentViewSettings(sendMsgHistoryItem));
        }
예제 #5
0
 /// <summary>
 /// Update of the Input is Available pass it through to the Interface
 /// </summary>
 /// <param name="newInputMsg"></param>
 public void InputUpdate(MsgData newInputMsg)
 {
     if (simulationInterface != null)
     {
         simulationInterface.InputUpdate(newInputMsg);
     }
 }
예제 #6
0
        /// <summary>
        /// Redirect the Log Messages Fromm the Connections
        /// </summary>
        /// <param name="logMessage"></param>
        public void SendRecivedEventHandler(object sender, MsgSendRecivedEventArgs e)
        {
            ConnectionInterface connection = sender as ConnectionInterface;

            if (e.msgData.type == MsgData.messageType.recived)
            {
                // Create a new Send Object!
                MsgData sendData = new MsgData(e.msgData.value, MsgData.messageType.redirect);

                if (connection.interfaceNumber == 1)
                {
                    connection2.Send(sendData);
                }
                else
                {
                    connection1.Send(sendData);
                }

                // Update the MsgLog bevore we send the Data to the Corresponding Data
                msgSendRecived(e);
            }
            else if (e.msgData.type == MsgData.messageType.send)
            {
                // Update the Msg Log with the injected Message by the User
                msgSendRecived(e);
            }
            else if (e.msgData.type == MsgData.messageType.infoPositive || e.msgData.type == MsgData.messageType.infoNegative)
            {
                msgSendRecived(e);
            }
        }
예제 #7
0
        /// <summary>
        /// Get the Value from the Message and convert it to an ASCII Charakter String
        /// This is used to show User hints
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public static string msgDataToAsciiChar(MsgData msg)
        {
            // Convert the Array of byte to a string
            ASCIIEncoding encoder = new ASCIIEncoding();

            return(encoder.GetString(msg.value, 0, (int)msg.value.LongLength));
        }
예제 #8
0
        /// <summary>
        /// Send Data to the Connected Serial Port
        /// </summary>
        /// <param name="message"></param>
        private void ConnectionInterface_Send(string message)
        {
            // If the Message is empty we do not send anything
            if (message == "")
            {
                return;
            }

            // Send the Data
            try
            {
                MsgData newSendMsg = msgLog.getRawMsgWithCurrentViewSettings(message);
                newSendMsg.connectionNumber = connectionSelectionSendData;
                if (connection.Send(newSendMsg) == 1)
                {
                    msgLog.messageWasSend(msgLog.getRawMsgWithCurrentViewSettings(message));
                    tbSendData.Text = "";
                }
            }
            catch
            {
                // Configure the message box to be displayed
                string           messageBoxText = "Die Eingaben passen nicht zu der aktuellen Darstellung. Bitte Eingaben überprüfen.";
                string           caption        = "Ungültige Eingabe für das Senden";
                MessageBoxButton button         = MessageBoxButton.OK;
                MessageBoxImage  icon           = MessageBoxImage.Warning;

                // Display message box
                MessageBox.Show(messageBoxText, caption, button, icon);
            }
        }
예제 #9
0
        /// <summary>
        /// This function allows to convert the User Inut String before storing the data in the ringbuffer
        /// </summary>
        /// <param name="stringMessage"></param>
        public MsgData getRawMsgWithCurrentViewSettings(string stringMessage)
        {
            // Define the needed Variables
            MsgData message = new MsgData();

            message.setCurrentTimeStamp();

            // Variables for the Split
            string[] splitValues = new string[] { ",", " " };
            string[] splitedMsg  = stringMessage.Split(splitValues, 1024, StringSplitOptions.RemoveEmptyEntries);
            byte[]   rawData     = new byte[splitedMsg.Length];

            // Convert the User Input to the Current Settings
            // Return the Msg with the Current View Configuration
            switch (viewSettings.dataPresentation)
            {
            default:    // ASCII Encoded Strings

                message.value = Converty.specialAsciiStringToMsgData(stringMessage);
                break;

            case 1:    // HEX Values of the Bytes recived

                for (int i = 0; i <= splitedMsg.Length - 1; i++)
                {
                    rawData[i] = Convert.ToByte(splitedMsg[i], 16);
                }

                message.value = rawData;

                break;

            case 2:    // DEC Values of the Bytes recived

                for (int i = 0; i <= splitedMsg.Length - 1; i++)
                {
                    rawData[i] = Convert.ToByte(splitedMsg[i], 10);
                }

                message.value = rawData;

                break;

            case 3:    // BIN Values of the Bytes recived

                for (int i = 0; i <= splitedMsg.Length - 1; i++)
                {
                    rawData[i] = Convert.ToByte(splitedMsg[i], 2);
                }

                message.value = rawData;

                break;
            }

            return(message);
        }
예제 #10
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public static string msgDataToDecData(MsgData msg)
        {
            var sb = new StringBuilder();

            foreach (char t in msg.value)
            {
                sb.Append(Convert.ToInt32(t).ToString("G") + " ");
            }
            return(sb.ToString());
        }
예제 #11
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public static string msgDataToBinData(MsgData msg)
        {
            var sb = new StringBuilder();

            foreach (byte t in msg.value)
            {
                sb.Append(Convert.ToString(t, 2) + " ");
            }
            return(sb.ToString());
        }
예제 #12
0
        /// <summary>
        /// Connect the Serial Port
        /// </summary>
        public void connect()
        {
            MsgData logMessage = new MsgData();

            // Check if we have to close the Serial Port!
            if (pcSerialPort != null)
            {
                if (pcSerialPort.IsOpen)
                {
                    pcSerialPort.Close();
                }
            }
            else
            {
                pcSerialPort = new SerialPort();
            }


            // Open the Serial Port
            try
            {
                // Set the Serial Paramter
                pcSerialPort.PortName = pcSerialParam.port;
                pcSerialPort.BaudRate = pcSerialParam.baud;
                pcSerialPort.DataBits = pcSerialParam.dataBits;
                pcSerialPort.Parity   = pcSerialParam.parity;
                pcSerialPort.StopBits = pcSerialParam.stopBits;

                // Add a new ComPort on Recive Handler
                pcSerialPort.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

                pcSerialPort.Open();

                // Set the User Hint
                logMessage.value = Encoding.ASCII.GetBytes("Verbindung: " + pcSerialPort.PortName + " Erfolgreich aufgebaut");
                logMessage.type  = MsgData.messageType.infoPositive;

                // Set the Event that the User Changed an Input
                MsgSendRecivedEventArgs msgLogEventArgs = new MsgSendRecivedEventArgs();
                msgLogEventArgs.msgData = logMessage;
                msgSendRecived(msgLogEventArgs);
            }
            catch (Exception)
            {
                // Set a User Hint
                logMessage.value = Encoding.ASCII.GetBytes("Verbindung: " + pcSerialPort.PortName + " Konnte nicht aufgebaut werden");
                logMessage.type  = MsgData.messageType.infoNegative;


                // Set the Event that the User Changed an Input
                MsgSendRecivedEventArgs msgLogEventArgs = new MsgSendRecivedEventArgs();
                msgLogEventArgs.msgData = logMessage;
                msgSendRecived(msgLogEventArgs);
            }
        }
예제 #13
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public static string msgDataToHexData(MsgData msg)
        {
            var sb = new StringBuilder();

            foreach (char t in msg.value)
            {
                //sb.Append(String.Format("{0:X}", t));
                sb.Append(Convert.ToInt32(t).ToString("x2") + " ");
            }

            return(sb.ToString().ToUpper());
        }
예제 #14
0
        /// <summary>
        /// Try to send the Data to the Requested Connection
        /// </summary>
        /// <param name="message"></param>
        /// <returns></returns>
        public int Send(MsgData message)
        {
            if (message.connectionNumber == 1)
            {
                connection1.Send(message);
            }
            else
            {
                connection2.Send(message);
            }

            return(1);
        }
예제 #15
0
        /// <summary>
        /// Update the ui With an Log Message and trigger the UpdateStatusBar
        /// </summary>
        /// <param name="rtbMsg">Message for the Log Window</param>
        /// <param name="msgType">Msg Type</param>
        private void updateUi(string rtbMsg, MsgData.messageType msgType)
        {
            // Set the User Hint to the TextBox
            MsgData logMessage = new MsgData();

            logMessage.value = Encoding.ASCII.GetBytes(rtbMsg);
            logMessage.type  = msgType;

            // Set the Event that the User Changed an Input
            MsgSendRecivedEventArgs msgLogEventArgs = new MsgSendRecivedEventArgs();

            msgLogEventArgs.msgData = logMessage;
            msgSendRecived(msgLogEventArgs);
        }
예제 #16
0
        /// <summary>
        /// Send the Data to the Eventhandler.. To update the Main UI and send the Data to teh Connection
        /// </summary>
        private void SendData(string data)
        {
            // Set the User Hint to the TextBox
            MsgData _logMessage = new MsgData();

            _logMessage.value = Converty.specialAsciiStringToMsgData(data);
            _logMessage.type  = MsgData.messageType.send;

            // Set the Event that the User Changed an Input
            MsgSendRecivedEventArgs _msgLogEventArgs = new MsgSendRecivedEventArgs();

            _msgLogEventArgs.msgData = _logMessage;
            msgSendRecived(_msgLogEventArgs);
        }
예제 #17
0
        /// <summary>
        /// Control of the Simulation Working State
        /// </summary>
        /// <param name="requestedState">Set the State of the Simulation State Stop = Stopping end ending the Thread // Pause = Stop the Simulation but dont end it // Run = Start the Simulation </param>
        public void RequestStateChange(Simulation_State requestedState)
        {
            switch (requestedState)
            {
            // Stop the Simulation Thread
            case Simulation_State.Stop:

                // If the Thread is Paused we wake him up to kill him!
                if (state == Simulation_State.Pause)
                {
                    lastMsg = null;     // Discard the recived Msg's if we got some during the Pause state
                    simulationWorkingThread.Interrupt();
                    pauseThread = false;
                }

                stopThread = true;

                break;

            // Pause the Simulation Thread
            case Simulation_State.Pause:

                pauseThread = true;

                break;

            // Start the Simulation Thread
            case Simulation_State.Run:

                if (state == Simulation_State.Pause)
                {
                    lastMsg = null;     // Discard the recived Msg's if we got some during the Pause state
                    simulationWorkingThread.Interrupt();
                    pauseThread = false;
                }
                else
                {
                    simulationWorkingThread = new Thread(new ThreadStart(WorkingThread));
                    simulationWorkingThread.Start();
                    lastMsg = null;     // Discard the recived Msg's if we got some during the Pause state
                }

                break;

            default:
                // Console.WriteLine("No valit Simulation State Request enterd");
                break;
            }
        }
예제 #18
0
        /// <summary>
        /// Blocking call to wait for a specific MSG to recive
        /// </summary>
        /// <param name="data">Msg Data to be recived</param>
        private bool WaitForMsg(string data)
        {
            bool returnVal = false;

            // Only check the Data if thei are Valid
            if (lastMsg != null && lastMsg.type == MsgData.messageType.recived)
            {
                if (compareRecivedAndSimMessage(lastMsg, data))
                {
                    lastMsg   = null;// before leaving the loop erase the Data
                    returnVal = true;
                }
            }
            return(returnVal);
        }
예제 #19
0
        /// <summary>
        /// Try to send the Data to the Requested Connection
        /// </summary>
        /// <param name="message"></param>
        /// <returns>Not yet Implemented feature to return the Send was Completed or not</returns>
        public int Send(MsgData message)
        {
            message.type = MsgData.messageType.send;

            if (connectionSettings.functionSelect == 0)
            {
                singleConnection.Send(message);
            }
            else if (connectionSettings.functionSelect == 1)
            {
                multiConnection.Send(message);
            }

            return(1);
        }
예제 #20
0
        /// <summary>
        /// Click of the Quick Button
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void QuickButton_Click(object sender, RoutedEventArgs e)
        {
            Button _quickButton = sender as Button;

            // Set the User Hint to the TextBox
            MsgData logMessage = new MsgData();

            logMessage.value = Converty.specialAsciiStringToMsgData((String)_quickButton.Resources["data"]);
            logMessage.type  = MsgData.messageType.send;

            // Set the Event that the User Changed an Input
            MsgSendRecivedEventArgs msgLogEventArgs = new MsgSendRecivedEventArgs();

            msgLogEventArgs.msgData = logMessage;
            msgSendRecived(msgLogEventArgs);
        }
예제 #21
0
        /// <summary>
        /// Send Data to the Client or Server
        /// </summary>
        /// <param name="message"></param>
        public void send(MsgData message)
        {
            if (tcpClient.Connected)
            {
                NetworkStream clientStream = tcpClient.GetStream();
                clientStream.Write(message.value, 0, message.value.Length);
                clientStream.Flush();

                message.setCurrentTimeStamp();              // Set the Time Stamp
                message.connectionNumber = interfaceNumber; // Set the reference to the Interface

                // Set the Event that the User Changed an Input
                MsgSendRecivedEventArgs msgLogEventArgs = new MsgSendRecivedEventArgs();
                msgLogEventArgs.msgData = message;
                msgSendRecived(msgLogEventArgs);
            }
        }
예제 #22
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="inputKey"></param>
        public void KeyInpuEvent(Key inputKey)
        {
            foreach (Button _button in buttonList)
            {
                if ((Key)_button.Resources["shortCut"] == inputKey)
                {
                    // Set the User Hint to the TextBox
                    MsgData logMessage = new MsgData();
                    logMessage.value = Converty.specialAsciiStringToMsgData((String)_button.Resources["data"]);
                    logMessage.type  = MsgData.messageType.send;

                    // Set the Event that the User Changed an Input
                    MsgSendRecivedEventArgs msgLogEventArgs = new MsgSendRecivedEventArgs();
                    msgLogEventArgs.msgData = logMessage;
                    msgSendRecived(msgLogEventArgs);
                }
            }
        }
예제 #23
0
        /// <summary>
        /// Try to send the Data to the Requested Connection
        /// </summary>
        /// <param name="message"></param>
        /// <returns></returns>
        public int Send(MsgData message)
        {
            if (connectionSettings.currentConnectionSetting == 1)
            {
                if (tcpConnection != null)
                {
                    tcpConnection.send(message);
                }
            }
            else if (connectionSettings.currentConnectionSetting == 2)
            {
                if (serialConnection != null)
                {
                    serialConnection.send(message);
                }
            }

            return(1);
        }
예제 #24
0
        /// <summary>
        /// Compare the simulation Data with the recived Data. With all the Fancy Placeholders and Special ASCII Chars
        /// </summary>
        /// <param name="recivedMsg"></param>
        /// <param name="simulationMsg"></param>
        /// <returns></returns>
        private bool compareRecivedAndSimMessage(MsgData recivedMsg, string simulationMsg)
        {
            // Clocking the Thread till we found what we are Searching for
            string _myData = Converty.msgDataToSpecialAsciiString(lastMsg.value);

            // Check if we got an Spacer int the String
            if (simulationMsg.IndexOf(SPACE_VALUE.ToString()) > -1)
            {
                string[] _splittedSimulationMsg = simulationMsg.Split(new Char[] { SPACE_VALUE });
                bool     dataValid = true;

                string _myString = _myData;

                foreach (string simulationMsgPart in _splittedSimulationMsg)
                {
                    if (!(_myString.IndexOf(simulationMsgPart) > -1))
                    {
                        // Cut the String that we fount out of the Buffer. So in this case we will check the Abendency in the Messages
                        _myString = _myString.Substring(_myString.IndexOf(simulationMsgPart) + simulationMsgPart.Length);
                        dataValid = false;
                    }
                }

                if (dataValid)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            else if (_myData == simulationMsg)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
예제 #25
0
        /// <summary>
        /// Disconnect the Serial Port
        /// </summary>
        public void disconnect()
        {
            // Check if we have to close the Serial Port!
            if (pcSerialPort != null)
            {
                if (pcSerialPort.IsOpen)
                {
                    pcSerialPort.Close();

                    // Set the User hint
                    MsgData logMessage = new MsgData();
                    logMessage.value = Encoding.ASCII.GetBytes("Verbindung: " + pcSerialPort.PortName + " Erfolgreich abgebaut");
                    logMessage.type  = MsgData.messageType.infoNegative;

                    // Set the Event that the User Changed an Input
                    MsgSendRecivedEventArgs msgLogEventArgs = new MsgSendRecivedEventArgs();
                    msgLogEventArgs.msgData = logMessage;
                    msgSendRecived(msgLogEventArgs);
                }
            }
        }
예제 #26
0
        /// <summary>
        /// By sending a new Message this function is called
        /// And we check if the entered Msg is already Stored in the List then remove it and add it to the First Place
        /// </summary>
        /// <param name="sendMessage"></param>
        public void messageWasSend(MsgData sendMessage)
        {
            // Try to find the Send Msg in the History Log
            sendHistory.Remove(sendMessage); // This is not working!

            // Create the needed Variables
            List <int> ListToRemove = new List <int>();

            // Finde the Duplicates in the send History
            for (int i = 0; i <= sendHistory.Count - 1; i++)
            {
                MsgData item = sendHistory.ElementAt <MsgData>(i);

                if (item.value.SequenceEqual(sendMessage.value))
                {
                    //Store the Index wie have to remove
                    ListToRemove.Add(i);
                }
            }

            // Remove the found Duplicates from the History List
            for (int i = 0; i <= ListToRemove.Count - 1; i++)
            {
                sendHistory.RemoveAt(ListToRemove.ElementAt <int>(i));
            }


            // Insert the new Message to the First Position of the Insert History
            sendHistory.Insert(0, sendMessage);

            // Remove the overlapping Data
            if (sendHistory.Count > 10)
            {
                sendHistory.RemoveAt(sendHistory.Count - 1);
            }


            // Init the Current viewed Histoy Message Index
            sendMsgHistoryCurrentIndex = -1;
        }
예제 #27
0
        /// <summary>
        /// Data Recive Handler
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            MsgData logMessage = new MsgData();

            byte[] message = new byte[4096];
            int    bytesRead;

            try
            {
                // Read the Data
                bytesRead = pcSerialPort.Read(message, 0, 4096);

                // Set the Current TimeStamp
                logMessage.setCurrentTimeStamp();

                // Save the Data to the
                logMessage.value = new byte[bytesRead];                    // Create an Array with the Size of readed Data
                Array.Copy(message, logMessage.value, bytesRead);          // Copy the Data to the Array
                logMessage.type             = MsgData.messageType.recived; //Set the Type to Recived Message
                logMessage.connectionNumber = interfaceNumber;             // Set the Interface Reference

                // Set the Event that the User Changed an Input
                MsgSendRecivedEventArgs msgLogEventArgs = new MsgSendRecivedEventArgs();
                msgLogEventArgs.msgData = logMessage;
                msgSendRecived(msgLogEventArgs);
            }
            catch (Exception ex)
            {
                // Set an error Message to the UI
                logMessage.value = Encoding.ASCII.GetBytes("Konnte nicht empfangen werden: " + "\n" + ex);
                logMessage.type  = MsgData.messageType.infoNegative;

                // Set the Event that the User Changed an Input
                MsgSendRecivedEventArgs msgLogEventArgs = new MsgSendRecivedEventArgs();
                msgLogEventArgs.msgData = logMessage;
                msgSendRecived(msgLogEventArgs);
            }
        }
예제 #28
0
        /// <summary>
        /// Returns the Data from the Next MSG in the Send History
        /// </summary>
        /// <returns></returns>
        public string getNextSendedMsg()
        {
            // Check if the History allready exist
            if (sendHistory.Count == 0)
            {
                return("");
            }

            MsgData sendMsgHistoryItem = new MsgData();

            // Decrement the Index of the History List
            if (sendMsgHistoryCurrentIndex <= 0)
            {
                sendMsgHistoryCurrentIndex = sendHistory.Count - 1;// Keep in mind that the list is 0 Based!!!
            }
            else
            {
                sendMsgHistoryCurrentIndex--;
            }

            sendMsgHistoryItem = sendHistory.ElementAt(sendMsgHistoryCurrentIndex);

            return(getMsgWithCurrentViewSettings(sendMsgHistoryItem));
        }
예제 #29
0
        /// <summary>
        ///  Convert the given Msg to the current view Setting as a String
        /// </summary>
        /// <returns></returns>
        public string getMsgWithCurrentViewSettings(MsgData msg)
        {
            string returnMsg;

            // Only change the view to the Sended and Recived Data
            if (msg.type == MsgData.messageType.recived || msg.type == MsgData.messageType.send)
            {
                // Return the Msg with the Current View Configuration
                switch (viewSettings.dataPresentation)
                {
                case 1:
                    returnMsg = Converty.msgDataToHexData(msg);
                    break;

                case 2:
                    returnMsg = Converty.msgDataToDecData(msg);
                    break;

                case 3:
                    returnMsg = Converty.msgDataToBinData(msg);
                    break;

                // Default View String with ASCII Chars
                default:
                    returnMsg = Converty.msgDataToSpecialAsciiString(msg.value);
                    break;
                }
            }
            else
            {
                returnMsg = Converty.msgDataToAsciiChar(msg);
            }


            return(returnMsg);
        }
예제 #30
0
        /// <summary>
        /// Change the View State
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ChangeViewDown_EventHandler(object sender, RoutedEventArgs e)
        {
            // Save the current SendBox Data with the Current View Settings
            try
            {
                currentSendData = msgLog.getRawMsgWithCurrentViewSettings(tbSendData.Text);
            }
            catch (Exception err)
            {
                currentSendData = msgLog.getRawMsgWithCurrentViewSettings("");
            }

            if (settings.viewSettings.dataPresentation <= 0)
            {
                settings.viewSettings.dataPresentation = 3;
            }
            else
            {
                settings.viewSettings.dataPresentation--;
            }

            msgLog.viewSettings = settings.viewSettings;
            UpdateViewStateDependence(settings.viewSettings);
        }