private void BarAdded(Core.Model.Bar bar) { var track = TrackHeaders.GetChildren <UI.Track>().SingleOrDefault(t => t.Model == bar.Track); var row = Grid.GetRow(track); var column = bar.Track.Bars.IndexOf(bar); while (BarGrid.ColumnDefinitions.Count <= column) { BarGrid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(Constants.BarWidth) }); } var ui = new UI.Bar(bar, track); ui.Selected += (s, b) => { SelectedBar?.Deselect(); SelectedBar = ui; }; bar.Updated += (s, fullUpdate) => { ui.FullUpdate = fullUpdate; UpdateBars.Enqueue(ui); }; Grid.SetRow(ui, row); Grid.SetColumn(ui, column); BarGrid.Children.Add(ui); AddLog("Bar added"); }
/// <summary> /// OnReceive is our Callback that gets called by the .NET socket class when new data arrives on the socket /// </summary> /// <param name="asyn"></param> private void OnReceive(IAsyncResult asyn) { // first verify we received data from the correct socket. This check isn't really necessary in this example since we // only have a single socket but if we had multiple sockets, we could use this check to use the same callback to recieve data from // multiple sockets if (asyn.AsyncState.ToString().Equals("Derivative")) { // read data from the socket. int iReceivedBytes = 0; iReceivedBytes = m_sockDerivative.EndReceive(asyn); // set our flag back to true so we can call begin receive again m_bDerivativeNeedBeginReceive = true; // in this example, we will convert to a string for ease of use. string sData = Encoding.ASCII.GetString(m_szDerivativeSocketBuffer, 0, iReceivedBytes); // When data is read from the socket, you can get multiple messages at a time and there is no guarantee // that the last message you receive will be complete. It is possible that only half a message will be read // this time and you will receive the 2nd half of the message at the next call to OnReceive. // As a result, we need to save off any incomplete messages while processing the data and add them to the beginning // of the data next time. sData = m_sDerivativeIncompleteRecord + sData; // clear our incomplete record string so it doesn't get processed next time too. m_sDerivativeIncompleteRecord = ""; // now we loop through the data breaking it appart into messages. Each message on this port is terminated // with a newline character ("\n") string sLine = ""; int iNewLinePos = -1; while (sData.Length > 0) { iNewLinePos = sData.IndexOf("\n"); if (iNewLinePos > 0) { sLine = sData.Substring(0, iNewLinePos); //UpdateListview(sLine); dout(sLine.Trim()); // move on to the next message. This isn't very efficient but it is simple (which is the focus of this example). sData = sData.Substring(sLine.Length + 1); if (sLine.StartsWith(string.Format("{0},BH,", this.RequestID)) || sLine.StartsWith(string.Format("{0},BC,", this.RequestID))) { UpdateBars?.Invoke(new BarUpdateIQ(sLine)); } } else { // we get here when there are no more newline characters in the data. // save off the rest of message for processing the next batch of data. m_sDerivativeIncompleteRecord = sData; sData = ""; } } // call wait for data to notify the socket that we are ready to receive another callback WaitForData("Derivative"); } }
public MainPage() { this.InitializeComponent(); SetStatus("Initialising ..."); App.Current.UnhandledException += (s, e) => AddLog(e.Message); Background = Constants.ApplicationBackgroundBrush; StatusBar.Background = Constants.StatusBarBackgroundBrush; StatusBar.BorderBrush = Constants.StatusBarBorderBrush; ConsoleRow.Height = new GridLength(0); InitialiseKeyboardAccelerators(); CreateSong(); Timer = new System.Timers.Timer(100); Timer.Elapsed += (s, e) => { while (UpdateBars.Any()) { UpdateBars.TryDequeue(out UI.Bar bar); UI.Utilities.CallUI(() => bar?.Update()); } if (UpdatePosition) { UI.Utilities.CallUI(() => Position.Text = Song.GetTime().ToTimeString()); UpdatePosition = false; } }; Timer.Start(); Audio = new UwpAudio(); Audio.Ready += (s, e) => OnAudioReady(); }