Okay, I've been thinking more about how bindings are processed when you have a mixture
of events coming in through the host and directly from MIDI devices. Here is the problem
I think we're having.

In the past it was usually only necessary to have the plugin open a MIDI input device directly
when it wanted to receive MIDI clocks from something since these aren't always passed reliably
through the host. For all other cases it is usually better to let the host handle MIDI devices and get everything through it.

This changed when I went to VST3 because VST3 can't receive program change messages from the host.
So now, alexs1 and several others have been making the plugin open input devices in order to get program changes.

The problem is that if you also allow the host to receive MIDI from the same device, these messages
may also be passed in to the Mobius plugin. This results in events being received twice,
once from the direct input device and once from the host. This is bad for most things. One
of the things seen recently is Mute not appearing to work. The reason was because Mute toggles
on and off and if there are two MIDI events for Mute in the queue it goes on and then off instantly
and nothing happens.

The easiest way to solve this is to prevent the host from using that device. Mobius gets all MIDI
from the direct device and nothing from the host. But that's a problem if the controller or keyboard
you're using also needs to be seen by the host for host commands or host recording. You can have
both Mobius and the host using the same input device provided that you do not cause the host to route
events from that device into Mobius. How flexible hosts are on MIDI routing vary.

If for some reason you can't make the host stop routing events from the shared device into Mobius
we've got the duplicate problem. Before we get into the possible new options around this, think
about your host routing and see if there isn't a way to control which devices will be sent into
Mobius.

Now, let's assume you can't control that. I see two simple options and a few more complicated ones.

The first is a flag that can be set somewhere that causes Mobius to ignore bindings on any events
received from the host. You can still record MIDI events from the host, but they won't run
any of the functions. Bindings will only work from the device you have opened directly. If the host
is duplicating those events it won't matter because we'll ignore the duplicates. This should work
well in simple cases since if you're bothering to open a MIDI device just to get program changes,
you may as well get all of them from there, you don't need anything from the host.

Where this doesn't work if you have two devices, one routed directly to Mobius and one routed through
the host, and you want to receive events from both of them. If you turn off host bindings it will
effectively disable bindings from the second device. You could work around that by again having
Mobius directly open the second device, but this starts to become tedious if you have a lot of devices. A more serious problem is if you want the host to send Mobius processed MIDI events. The host receives an event and changes it or replicates it, and sends the result into Mobius. Or you're using a pre-recorded host MIDI track containing Mobius commands and you want to "play" that into Mobius. You can't do either of those things if you disable host bindings.

While I think those last two cases are rare, they could happen. A second option I can add is a flag that tells Mobius to only pay attention to MIDI event bindings coming from direct devices if they are program changes. All other note and CC bindings must come through the host. This works around the problem of not being able to receive program changes through the host while still allowing the host to send any other MIDI events into Mobius.

I think between those two options, and more careful attention to how you're doing MIDI routing
int the host we should be able to prevent duplicates. But there are more complex things we could do
as well. This "only use program changes" option could be per-device rather than applying to all
of them. Each device could have an "App Control" checkbox in the MIDI configuration panel that
controls whether this device can do bindings at all. Before we start down that path though, I'd
like to see if we can solve the problems that have come up using only the two simple options.

 * ignore host bindings
 * only process  program changes received from direct devices