/// <summary>
/// Triggers a javascript event on this implant. Events not
/// in range will be simply ignored.
/// </summary>
public void Trigger(ImplantEvent e)
{
if (ImplantInstance != null)
{
ImplantInstance.Trigger(e);
}
}
/// <summary>
/// Called only by the kernel
/// </summary>
internal void TriggerFromKernel(ImplantEvent e)
{
MappedMidiDevice device = e.Hardware;
// allow event interception
if (ImplantEventTriggered != null)
{
ImplantEventTriggered(this, e);
}
// OSC events are special. they are delievered to all
// implants except their source
// TODO: likely need an OSC registration system so only
// implants that have registered for a specific OSC address
// will get the message
if (e is OscImplantEvent)
{
var osc = e as OscImplantEvent;
if (osc.Osc != null)
{
foreach (var implant in Items.ToArray())
{
if (implant.Active && implant.Running)
{
if (implant.GetSourceName() != osc.Osc.Source)
{
implant.Trigger(e);
}
}
}
}
return;
}
// determine which implants are to receive the event
if (device == null || SendToAllEvents(e))
{
// send these events to all implants untranslated
// TODO: how do we deal with visible here?
foreach (var implant in Items.ToArray())
{
if (implant.Active && implant.Running)
{
implant.Trigger(e);
}
}
}
else
{
// send translated event to each implant.
var targets = GetImplantsByPhysicalAddress(device, e, true);
foreach (var implant in targets.Keys)
{
implant.Trigger(targets[implant]);
}
}
}
/// <summary>
/// Sends implant event to EventReceived.
/// </summary>
public void Trigger(ImplantEvent ie)
{
if (ie != null)
{
ie.Hardware = this.Mapping;
ie.ScheduleTask();
}
}
/// <summary>
/// Called by MidiInput to translate a midi message to an
/// implant event to trigger. Exposed here to allow simulated
/// devices to insert data into the event chain.
/// </summary>
public void Trigger(MidiMessage m)
{
ImplantEvent e = Convert(m);
if (e != null)
{
e.CausedBy = m;
Trigger(e);
}
}
/// <summary>
/// Returns true if a given event is one that should go to
/// all implants.
/// </summary>
private bool SendToAllEvents(ImplantEvent e)
{
if (e is PadImplantEvent)
{
return(false);
}
if (e is KnobImplantEvent)
{
return(false);
}
return(true);
}
/// <summary>
/// Converts a raw MIDI message into an event ready to be
/// sent to an implant.
/// </summary>
public override ImplantEvent Convert(MidiMessage midi)
{
// convert to XY
int x;
int y;
ImplantEventType type;
XYMapper.ConvertXY(midi.Type, midi.Pitch, out x, out y, out type);
if (type == ImplantEventType.PadPress)
{
if (midi.Value == 0)
{
type = ImplantEventType.PadRelease;
}
else if (IsDoublePress(midi))
{
type = ImplantEventType.PadDoubleClick;
}
}
// create event
ImplantEvent ret = null;
switch (type)
{
case ImplantEventType.KnobChange:
ret = new KnobChangeImplantEvent();
break;
case ImplantEventType.PadPress:
ret = new PadPressImplantEvent();
break;
case ImplantEventType.PadRelease:
ret = new PadReleaseImplantEvent();
break;
case ImplantEventType.PadDoubleClick:
ret = new PadDoubleClickImplantEvent();
break;
}
// set standard values
if (ret != null)
{
ret.X = x;
ret.Y = y;
ret.Value = midi.Value;
}
return(ret);
}
/// <summary>
/// Passes on an event to the appropriate javascript methods.
/// Out of range events will be simply ignored.
/// </summary>
public void Trigger(ImplantEvent e)
{
var jsEvent = e.Convert();
// if this event type has a target, trigger the event and record the destination
ImplantEventBaseJSInstance target = GetEventTarget(e);
if (target != null)
{
target.Trigger(jsEvent);
e.LogDestination(Parent.GetSourceName());
}
}
/// <summary>
/// Gets the event name for javascript from an implant event instance.
/// </summary>
internal static string GetJSEventName(ImplantEvent e)
{
if (e is Clock96ImplantEvent)
{
return("1/96");
}
if (e is KnobChangeImplantEvent)
{
return("change");
}
if (e is PadPressImplantEvent)
{
return("press");
}
if (e is PadReleaseImplantEvent)
{
return("release");
}
if (e is PadDoubleClickImplantEvent)
{
return("doublepress");
}
if (e is DeviceChangeImplantEvent)
{
return("devicechange");
}
if (e is ModeChangeImplantEvent)
{
return("modechanged");
}
if (e is GuiPaintImplantEvent)
{
return("paint");
}
if (e is NoteOnImplantEvent)
{
return("noteon");
}
if (e is NoteOffImplantEvent)
{
return("noteoff");
}
if (e is OscImplantEvent)
{
return("change");
}
return("unknown");
}
/// <summary>
/// Creates a note implant event from a midi message.
/// </summary>
public override ImplantEvent Convert(MidiMessage midi)
{
ImplantEvent ret = null;
switch (midi.Type)
{
case MidiMessageType.NoteOn:
ret = new NoteOnImplantEvent();
break;
case MidiMessageType.NoteOff:
ret = new NoteOffImplantEvent();
break;
}
if (ret != null)
{
ret.X = midi.Pitch;
ret.Value = midi.Velocity;
}
return(ret);
}
/// <summary>
/// Returns the instance of the object that should receive
/// a particular event, or null if none should.
/// </summary>
private ImplantEventBaseJSInstance GetEventTarget(ImplantEvent e)
{
if (e is Clock96ImplantEvent)
{
return(time);
}
else if (e is NoteImplantEvent)
{
return(keys);
}
else if (e is PadImplantEvent)
{
return(pads);
}
else if (e is KnobImplantEvent)
{
return(knobs);
}
else if (e is OscImplantEvent)
{
return(osc);
}
else if (e is GuiImplantEvent)
{
return(gui);
}
else if (e is ModeChangeImplantEvent)
{
return(mode);
}
else if (e is DeviceChangeImplantEvent)
{
return(this);
}
/*
* switch (e.EventType)
* {
* case ImplantEventType.GuiPaint:
* return gui;
* case ImplantEventType.NoteOn:
* case ImplantEventType.NoteOff:
* return keys;
* case ImplantEventType.KnobChange:
* return knobs;
* case ImplantEventType.PadPress:
* case ImplantEventType.PadRelease:
* case ImplantEventType.PadDoubleClick:
* return pads;
* case ImplantEventType.DeviceChange:
* return this;
* case ImplantEventType.ModeChange:
* return mode;
* case ImplantEventType.Clock96:
* return time;
* case ImplantEventType.OscMessage:
* return osc;
* }
*/
return(null);
}
/// <summary>
/// Returns the list of all Implants that are mapped to a given
/// device coordinate so we never waste time sending events
/// to implants that won't use them.
/// </summary>
private Dictionary <JavascriptImplant, ImplantEvent> GetImplantsByPhysicalAddress(MappedMidiDevice device, ImplantEvent e, bool visibleOnly = false)
{
// TODO: need to decide how to deal with modes here
var target = visibleOnly ? Visible.ToArray() : Items.ToArray();
var ret = new Dictionary <JavascriptImplant, ImplantEvent>();
foreach (var implant in target)
{
if (implant.Active == false)
{
continue;
}
if (implant.Running == false)
{
continue;
}
int vx, vy;
if (implant.ActiveArea.GetVirtualAddress(device, e.X, e.Y, out vx, out vy))
{
// TODO: scroll these?!!!
// clone this event with a virtual address for this implant
var implantEvent = e.Clone();
implantEvent.X = vx;
implantEvent.Y = vy;
ret.Add(implant, implantEvent);
}
}
return(ret);
}
