private void onChannelMessagePlayed(object sender, Midi.ChannelMessageEventArgs arg)
{
var command = arg.Message.Command;
if (command == Midi.ChannelCommand.NoteOn && arg.Message.Data2 == 0)
{
command = Midi.ChannelCommand.NoteOff;
}
switch (command)
{
case Midi.ChannelCommand.NoteOn:
Actions.Add(delegate {
Controller.setKeyPosition(arg.Message.Data1, 1);
});
break;
case Midi.ChannelCommand.NoteOff:
Actions.Add(delegate {
Controller.setKeyPosition(arg.Message.Data1, 0);
});
break;
}
}
/*private void HandleLoadCompleted(object sender, System.ComponentModel.AsyncCompletedEventArgs e)
* {
* Timer.text = sequence.GetLength().ToString();
* }*/
private void onChannelMessagePlayed(object sender, Midi.ChannelMessageEventArgs arg)
{
//Debug.Log("ChannelMessagePlayed: " + arg.Message.Command.ToString());
if (OutputToDevice)
{
outDevice.Send(arg.Message);
}
}
protected virtual void OnChannelMessageDispatched(ChannelMessageEventArgs e)
{
EventHandler <ChannelMessageEventArgs> handler = ChannelMessageDispatched;
if (handler != null)
{
handler(this, e);
}
}
private void HandleInputMessageReceived(object sender, ChannelMessageEventArgs args)
{
_uiCtx.Post(o =>
{
// Create new channel message object and add to session
ChannelMessage msg = args.Message;
if (MessageReceived != null) MessageReceived(this, SanfordUtils.ConvertChannelMessageToKeyStrokeEventArgs(msg));
}, null);
}
protected virtual void OnChannelMessageReceived(ChannelMessageEventArgs e)
{
EventHandler<ChannelMessageEventArgs> handler = ChannelMessageReceived;
if(handler != null)
{
context.Post(delegate(object dummy)
{
handler(this, e);
}, null);
}
}
private void InDevice_ChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
// raise event
if (OnControlMessageEvent == null) return;
if (e.Message.Command != ChannelCommand.Controller) return;
OnControlMessageEvent(new ControlMessageEventArgs
{
ControlId = e.Message.Data1,
Value = e.Message.Data2
});
}
protected virtual void OnChannelMessageReceived(ChannelMessageEventArgs e)
{
EventHandler <ChannelMessageEventArgs> handler = ChannelMessageReceived;
if (handler != null)
{
context.Post(delegate(object dummy)
{
handler(this, e);
}, null);
}
}
private void HandleChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
/*if (closing)
{
return;
}*/
if (e.Message.Command == ChannelCommand.NoteOn)
NotePlayed((object)(e.Message.MidiChannel), null);
outDevice.Send(e.Message);
//pianoControl1.Send(e.Message);
}
protected virtual void OnChannelMessageReceived(ChannelMessageEventArgs e)
{
EventHandler<ChannelMessageEventArgs> handler = ChannelMessageReceived;
if (context == null)
context = SynchronizationContext.Current;
if (handler != null && context != null)
{
context.Post(delegate(object dummy)
{
handler(this, e);
}, null);
}
}
protected virtual void OnChannelMessageReceived(ChannelMessageEventArgs e)
{
EventHandler <ChannelMessageEventArgs> handler = ChannelMessageReceived;
if (context == null)
{
context = SynchronizationContext.Current;
}
if (handler != null && context != null)
{
context.Post(delegate(object dummy)
{
handler(this, e);
}, null);
}
}
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
context.Post(delegate (object dummy)
{
if (e.Message.Data2 == 127)
{
switch (e.Message.Data1)
{
/*
5D = 93 = A 6 = Stop
5E = 94 = Bb 6 = Play
5F = 95 = B 6 = Record
60 = 96 = C 7 = Up
61 = 97 = C# 7 = Down
62 = 98 = D 7 = Left
63 = 99 = Eb 7 = Right
64 = 100 = E 7 = Center
*/
case 93:
home.HandleStopButtonPress();
break;
case 94:
home.HandlePlayButtonPress();
break;
case 95:
home.HandleRecordButtonPress();
break;
case 96:
home.HandleUpButtonPress();
break;
case 97:
home.HandleDownButtonPress();
break;
case 98:
home.HandleLeftButtonPress();
break;
case 99:
home.HandleRightButtonPress();
break;
case 100:
home.HandleCenterButtonPress();
break;
}
}
}, null);
}
void sequencer_ChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
if (serialPort == null)
{
return;
}
try
{
List<byte> dataBuffer = new List<byte>();
if (e.Message.Command == ChannelCommand.NoteOn || e.Message.Command == ChannelCommand.NoteOff)
{
dataBuffer.Add((byte)(e.Message.Command));
dataBuffer.Add((byte)e.Message.Data1);
dataBuffer.Add((byte)e.Message.Data2);
}
else if (e.Message.Command == ChannelCommand.Controller)
{
// Control change command
dataBuffer.Add((byte)(e.Message.Command));
dataBuffer.Add((byte)e.Message.Data1);
dataBuffer.Add((byte)e.Message.Data2);
}
foreach (byte data in dataBuffer)
{
Console.Write(data.ToString("X2"));
Console.Write(".");
}
serialPort.Write(dataBuffer.ToArray<byte>(), 0, dataBuffer.Count);
Console.WriteLine("");
}
catch (Exception ex)
{
serialPort = null;
}
}
/// <summary>
/// We've received a MIDI message - handle it appropriately for the game state and message type.
/// </summary>
void ChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
CheckReceivedMessage(e.Message);
}
private void inputDevice_ChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
log.Trace("Recv {4} cmd {0}, chn: {1} data1: {2} data2: {3}",
e.Message.Command,
e.Message.MidiChannel,
e.Message.Data1,
e.Message.Data2,
Name);
this.midiMessages.OnNext(e.Message);
try
{
var key = Tuple.Create(e.Message.MidiChannel, e.Message.Command, e.Message.Data1);
Action<ChannelMessage> action;
if (this.messageMapper.TryGetValue(key, out action))
{
action.Invoke(e.Message);
}
}
catch (Exception ex)
{
log.Error(ex, "Failed to invoke action");
}
}
void Instance_ChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
if (InvokeRequired)
{
this.BeginInvoke((Instance_ChannelMessageReceivedDel) Instance_ChannelMessageReceived, sender, e);
}
else
{
// Add event
var midiInputEvent = MidiFactory.Instance.CreateMidiEvent(e.Message.Command, e.Message.MidiChannel, e.Message.Data1, e.Message.Data2);
if (midiInputEvent != null)
{
MidiEventList.Add(midiInputEvent);
// select event
midiEventsBindingSource.MoveLast();
}
}
}
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
context.Post(delegate(object dummy)
{
channelListBox.Items.Add(
e.Message.Command.ToString() + '\t' + '\t' +
e.Message.MidiChannel.ToString() + '\t' +
e.Message.Data1.ToString() + '\t' +
e.Message.Data2.ToString());
channelListBox.SelectedIndex = channelListBox.Items.Count - 1;
}, null);
}
/// <summary>
/// Event handler for MIDI player - channel message played
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void HandleMIDIChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
}
public static ShortMessageEventArgs FromChannelMessage(ChannelMessageEventArgs arg)
{
return(new ShortMessageEventArgs(arg.Message));
}
/// <summary>
/// We got a ChannelMessage. If there's an OutputDevice, play the note!
/// </summary>
void VirtualKeyboard_ChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
if(_device != null)
_device.Send(e.Message);
}
private void HandlePlayerMessage(object o, ChannelMessageEventArgs e)
{
var pianoEventArgs = SanfordUtils.ConvertChannelMessageToKeyStrokeEventArgs(e.Message);
if(_output != null) _output.Send(this, pianoEventArgs);
if(_virtualKeyboard != null) _virtualKeyboard.HandleIncomingMessage(o, pianoEventArgs);
}
static void MIDIChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
outDevice.Send(e.Message);
}
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
if (ChannelMessageReceived != null) ChannelMessageReceived(sender, e);
}
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
// textBox1.Text += "message=" + e.Message.Command + "; ID=" + e.Message.Data1 + "; Val=" + e.Message.Data2 + "\r\n";
int PanelID = e.Message.Data1;
for (int x = 0; x < 4; x++)
{
for (int y = 0; y < 2; y++)
{
if (Convert.ToInt32(panele[x, y].Tag) == PanelID)
{
panel1_Click(panele[x, y], null);
IGame game = GameController.Instance().currentGame;
if (game != null)
{
game.ButtonPress(x, y);
}
}
}
}
if (PanelID == 25)
{
int val = e.Message.Data2 / 10;
if (val < lbxGames.Items.Count)
{
lbxGames.SelectedIndex = val;
IGame game = GameController.Instance().currentGame;
if (game ==null || (int)game.GameType != val)
{
GameController.Instance().StartGame((GameType)val, CurrentGame_Repaint);
}
}
}
}
/// <summary>
/// Handles the Midi message received
/// Only called if in recording mode
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
m_context.Post(delegate(object dummy)
{
// Create new channel message object and add to session
ChannelMessage msg = e.Message;
//todo: maybe reimplement this if broken new ChannelMessage(e.Message.Command,e.Message.MidiChannel,e.Message.Data1,e.Message.Data2);
m_Session.Record(msg);
// Update number of messages received and raise event
this.NumMsgsReceived++;
if (MessageReceived != null) MessageReceived(this, SanfordUtils.ConvertChannelMessageToKeyStrokeEventArgs(msg));
}, null);
}
/// <summary>
/// Internal event handler for channel message played
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void HandleChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
if (b_ProgramClosing) // don't try playing anything if program is closing
return;
// always play NoteOff messages
if (e.Message.Command == ChannelCommand.NoteOn && e.Message.Data2 > 0)
{
if (!PlayOtherChannels && e.Message.MidiChannel != i_PersistentChannel)
return;
if (!PlayPersistentChannel && e.Message.MidiChannel == i_PersistentChannel)
return;
}
if (e.Message.MidiChannel == i_PersistentChannel)
{
if (e.Message.Command == ChannelCommand.NoteOn && e.Message.Data2 > 0)
{
i_NumChannelNotesPlayed++;
al_CurrentPlayingChannelNotes.Add(e.Message.Data1 + NoteOffset);
e = new ChannelMessageEventArgs(new ChannelMessage(e.Message.Command, e.Message.MidiChannel, e.Message.Data1 + NoteOffset, e.Message.Data2));
}
else if (e.Message.Command == ChannelCommand.NoteOn || e.Message.Command == ChannelCommand.NoteOff)
{
al_CurrentPlayingChannelNotes.Remove(e.Message.Data1 + NoteOffset);
e = new ChannelMessageEventArgs(new ChannelMessage(e.Message.Command, e.Message.MidiChannel, e.Message.Data1 + NoteOffset, e.Message.Data2));
}
}
outputDevice.Send(e.Message);
}
private void MidiDeviceManager_ChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
MidiEventBase eventBase = GetMidiInputEvent(MidiEventBase.GetID(e.Message));
if (eventBase != null) eventBase.SetData(e.Message);
}
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
context.Post(delegate (object dummy)
{
if (cbDebug.Checked)
{
logMe("Got MIDI " + e.Message.Command.ToString() +
" on channel " + (e.Message.MidiChannel + 1) + ", note: " +
e.Message.Data1 + "\n");
}
if ((e.Message.Command.ToString()=="NoteOn") &&
(e.Message.MidiChannel + 1 == nudMidiChannel.Value))
{
if (e.Message.Data1 >=48)
{
// 48 == C3
int iPlaylistItem = e.Message.Data1 - 48;
logMe("Playing playlist item #" + iPlaylistItem.ToString() + "\n");
PlayPlayListItem(iPlaylistItem + 4);
}
}
}, null);
}
private static void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
System.Diagnostics.Debug.WriteLine(string.Format("{0}, {1}, {2}, {3}, {4}, {5}", e.Message.Command.ToString(),
e.Message.Data1, e.Message.Data2, e.Message.MessageType.ToString(), e.Message.MidiChannel, e.Message.Status));
switch (e.Message.Command)
{
case ChannelCommand.NoteOn:
foreach (VirtualPiano inst in _pianoInstances)
{
inst.handlePianoDown(e.Message.Data1);
}
break;
case ChannelCommand.NoteOff:
foreach (VirtualPiano inst in _pianoInstances)
{
inst.handlePianoUp(e.Message.Data1);
}
break;
default:
break;
}
}
private void HandleChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
if (closing)
{
return;
}
if (Dispatcher.Thread == Thread.CurrentThread)
{
outDevice.Send(e.Message);
piano.Send(e.Message);
}
else
{
Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal,
new EventHandler<ChannelMessageEventArgs>(HandleChannelMessagePlayed), sender, new object[] { e });
}
}
protected virtual void OnChannelMessageDispatched(ChannelMessageEventArgs e)
{
ChannelMessageDispatched?.Invoke(this, e);
}
private void ChannelMessageReceived(
object sender,
ChannelMessageEventArgs e
)
{
//System.Diagnostics.Debug.WriteLine(
// "MIDI channel message on channel " + e.Message.MidiChannel +
// " with command " + e.Message.Command +
// ", data1 " + e.Message.Data1 +
// ", data2 " + e.Message.Data2
//);
MidiCommand command;
if (e.Message.Command == ChannelCommand.Controller) {
double value = (double)e.Message.Data2 / 127;
command = new MidiCommand() {
type = MidiCommandType.Knob,
index = e.Message.Data1,
value = value,
};
} else if (
e.Message.Command == ChannelCommand.NoteOn ||
e.Message.Command == ChannelCommand.NoteOff
) {
double value = (double)e.Message.Data2 / 127;
command = new MidiCommand() {
type = MidiCommandType.Note,
index = e.Message.Data1,
value = value,
};
} else if (e.Message.Command == ChannelCommand.ProgramChange) {
command = new MidiCommand() {
type = MidiCommandType.Program,
index = e.Message.Data1,
};
} else {
return;
}
this.buffer.Enqueue(command);
List<Binding> triggered = new List<Binding>();
BindingKey genericKey = new BindingKey(command.type, -1);
if (this.bindings.ContainsKey(genericKey)) {
triggered.AddRange(this.bindings[genericKey]);
}
BindingKey key = new BindingKey(command.type, command.index);
if (this.bindings.ContainsKey(key)) {
triggered.AddRange(this.bindings[key]);
}
foreach (Binding binding in triggered) {
binding.callback(command.index, command.value);
}
}
protected virtual void OnChannelMessageDispatched(ChannelMessageEventArgs e)
{
EventHandler<ChannelMessageEventArgs> handler = ChannelMessageDispatched;
if(handler != null)
{
handler(this, e);
}
}
private void sequencer_ChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
MIDIOutPutDevice.Send(e.Message);
}
private void HandleChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
if(closing)
{
return;
}
outDevice.Send(e.Message);
pianoControl1.Send(e.Message);
}
private void EventSource_ChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
FOutDevice.Send(e.Message);
}
private void ExecuteChannelMessageAction(ChannelMessageEventArgs channelMessageEventArgs)
{
var incomingMessage = channelMessageEventArgs.Message;
var translations = TranslationMap?.Translations.Where(t => t.InputMatchFunction(incomingMessage, t.InputMessageMatchTarget)).ToList();
if (translations != null && translations.Any())
{
translations
.ToList()
.ForEach(translation =>
{
var translatedMessage = translation.TranslationFunction(incomingMessage, translation.OutputMessageTemplate);
ChannelMessageActions.Where(channelMessageAction => channelMessageAction.MatchFunction(translatedMessage.ToChannelMessage()))
.ToList()
.ForEach(c =>
{
c.Action(translatedMessage.ToChannelMessage());
});
});
}
else
{
ChannelMessageActions.Where(channelMessageAction => channelMessageAction.MatchFunction(incomingMessage))
.ToList()
.ForEach(c =>
{
c.Action(incomingMessage.ToChannelMessage());
});
}
}
private void HandleChannelMessagePlayed(object sender, ChannelMessageEventArgs e)
{
if (closing)
{
return;
}
outDevice.Send(e.Message);
if (e.Message.Command == ChannelCommand.ProgramChange)
{
if (!dicChannel.ContainsKey(e.Message.MidiChannel))
{
dicChannel.Add(e.Message.MidiChannel, e.Message.Data1);
}
}
if (e.Message.MidiChannel == 9) // Channel 9 is reserved for drums
{
this.Dispatcher.Invoke(
System.Windows.Threading.DispatcherPriority.Normal,
new Action(
delegate()
{
drumControl1.Send(e.Message);
}
));
}
else if (dicChannel.ContainsKey(e.Message.MidiChannel))
{
switch (dicChannel[e.Message.MidiChannel])
{
case (int)MIDIInstrument.AcousticGrandPiano://1
case (int)MIDIInstrument.BrightAcousticPiano://2
case (int)MIDIInstrument.ElectricGrandPiano://3
case (int)MIDIInstrument.HonkytonkPiano://4
case (int)MIDIInstrument.ElectricPiano1://5
case (int)MIDIInstrument.ElectricPiano2://6
case (int)MIDIInstrument.Harpsichord://7
case (int)MIDIInstrument.Clavinet://8
pianoControl1.Send(e.Message);
break;
case (int)MIDIInstrument.AcousticGuitarnylon://25
case (int)MIDIInstrument.AcousticGuitarsteel://26
case (int)MIDIInstrument.ElectricGuitarjazz://27
case (int)MIDIInstrument.ElectricGuitarclean://28
case (int)MIDIInstrument.ElectricGuitarmuted://29
case (int)MIDIInstrument.OverdrivenGuitar://30
case (int)MIDIInstrument.DistortionGuitar://31
case (int)MIDIInstrument.GuitarHarmonics://32
this.Dispatcher.Invoke(
System.Windows.Threading.DispatcherPriority.Normal,
new Action(
delegate()
{
guitarControl1.Send(e.Message);
}
));
break;
case (int)MIDIInstrument.AcousticBass://33
case (int)MIDIInstrument.ElectricBassfinger://34
case (int)MIDIInstrument.ElectricBasspick://35
case (int)MIDIInstrument.FretlessBass://36
case (int)MIDIInstrument.SlapBass1://37
case (int)MIDIInstrument.SlapBass2://38
case (int)MIDIInstrument.SynthBass1://39
case (int)MIDIInstrument.SynthBass2://40
this.Dispatcher.Invoke(
System.Windows.Threading.DispatcherPriority.Normal,
new Action(
delegate()
{
bassControl1.Send(e.Message);
}
));
break;
default:
pianoControl1.Send(e.Message);
break;
}
}
}
private void HandleChannelMessageReceived(object sender, ChannelMessageEventArgs e)
{
//context.Post(delegate(object dummy)
//{
textBox1.Text += "message = " + e.Message.Command + "; ID" + e.Message.Data1 + "\r\n";
int PanelID = e.Message.Data1;
for (int x = 0; x < 4; x++)
{
for (int y = 0; y < 4; y++)
{
if (Convert.ToInt32(panele[x, y].Tag) == PanelID)
{
//if (e.Message.Command == ChannelCommand.NoteOn)
// ZapalPanel(panele[x, y], Color.Orange);
//else
// ZapalPanel(panele[x, y], Color.Black);
if (e.Message.Command == ChannelCommand.NoteOff)
panel13_MouseClick(panele[x, y], null);
}
}
}
//}, null);
//SprawdzDroge_Click(null, null);
}
