public void SetBinding(AMidiDefinition binding)
{
var changed = _mapping.SetBinding(_device, binding);
if (changed)
{
raisePropertyChanged("MidiBinding");
raisePropertyChanged("MappedTo");
IsChanged = true;
}
}
private void updateBinding(AMidiDefinition definition = null)
{
string expression;
AMidiDefinition tmpDefinition;
foreach (var mapping in _mappings)
{
expression = null;
tmpDefinition = definition;
if (IsGenericMidi)
{
if (!String.IsNullOrEmpty(_channel))
{
if (!String.IsNullOrEmpty(_note))
{
expression = _channel + "." + _note.Replace("+", "+" + _channel + ".");
}
else if (mapping.MidiBinding != null)
{
expression = Regex.Replace(mapping.MidiBinding.Note, @"Ch\d+", _channel);
}
}
else if (!String.IsNullOrEmpty(_note))
{
if (mapping.MidiBinding != null)
{
var channel = mapping.MidiBinding.Note.Substring(0, 4);
expression = channel + "." + _note.Replace("+", "+" + channel + ".");
}
}
if (expression != null)
{
tmpDefinition = AGenericMidiDefinition.Parse(mapping.Command.MappingType, expression);
}
}
else
{
if (tmpDefinition != null && mapping.Command.MappingType != tmpDefinition.Type)
{
tmpDefinition = _proprietaryDefinitions.First(p => p.Type == mapping.Command.MappingType && p.Note == tmpDefinition.Note);
}
}
mapping.SetBinding(tmpDefinition);
}
analyzeSelection();
updateMenus();
}
internal Mapping(Device device, Format.Mapping rawMapping)
: this(rawMapping)
{
Attach(device);
if (Id >= 0)
{
Format.MidiDefinition rawDefinition = getMidiDefinition(device, Command.MappingType, Id);
if (rawDefinition != null)
{
MidiBinding = AMidiDefinition.Parse(device.TypeStr, Command.MappingType, rawDefinition);
}
}
}
private void updateMidiDefinitions()
{
var definitions = RawDevice.Data.MidiDefinitions;
if (definitions != null)
{
foreach (var inDef in definitions.In.Definitions)
{
_midiInDefinitions[inDef.MidiNote] = AMidiDefinition.Parse(TypeStr, MappingType.In, inDef);
}
foreach (var outDef in definitions.Out.Definitions)
{
_midiOutDefinitions[outDef.MidiNote] = AMidiDefinition.Parse(TypeStr, MappingType.Out, outDef);
}
}
}
internal Mapping(Device device, Format.Mapping rawMapping)
: this(rawMapping)
{
if (Command == null) //pestrela: favorites crash
{
return;
}
Attach(device);
if (Id >= 0)
{
Format.MidiDefinition rawDefinition = getMidiDefinition(device, Command.MappingType, Id);
if (rawDefinition != null)
{
MidiBinding = AMidiDefinition.Parse(device.TypeStr, Command.MappingType, rawDefinition);
}
}
}
/// <summary>
/// Removes the given binding and optionally its corresponding definition, if it is not used any more,
/// </summary>
/// <param name="bindingId">Id of binding to remove</param>
/// <param name="definition">Optional. Remove definition if not used by another binding.</param>
private void removeBinding(int bindingId, AMidiDefinition definition = null)
{
var deviceData = RawDevice.Data;
var bindings = deviceData.Mappings.MidiBindings.Bindings;
// remove old binding and check if old definition can be removed too, because it is not used in another binding
var oldBinding = bindings.SingleOrDefault(b => b.BindingId.Equals(bindingId));
if (oldBinding != null)
{
bindings.Remove(oldBinding);
if (definition != null)
{
var oldBindings = bindings.Where(b => b.MidiNote.Equals(definition.Note));
if (!oldBindings.Any())
{
removeDefinition(definition);
}
}
}
}
private void removeDefinition(AMidiDefinition definition)
{
var deviceData = RawDevice.Data;
var definitions = (definition.Type == MappingType.In) ? deviceData.MidiDefinitions.In.Definitions : deviceData.MidiDefinitions.Out.Definitions;
int removedCount = definitions.RemoveAll(d => d.MidiNote.Equals(definition.Note));
if (removedCount > 0)
{
if (definition.Type == MappingType.In)
{
_midiInDefinitions.Remove(definition.Note);
}
else
{
_midiOutDefinitions.Remove(definition.Note);
}
}
if (removedCount > 1)
{
// TODO: Something for the consolidation function
}
}
/// <summary>
/// Set binding.
/// </summary>
/// <param name="device">The device this mapping belongs to. </param>
/// <param name="midi">AMidiDefinition or null to reset binding.</param>
/// <returns>True if binding was changed.</returns>
public bool SetBinding(Device device, AMidiDefinition midi) // if the Device paramater was left out, it would be possible to make an invalid binding.
{
// given device and definition do not match. binding cannot be kept.
if (midi != null && device.TypeStr != midi.DeviceTypeStr)
{
MidiBinding = null;
return(true);
}
// midi definitions and bindings
var deviceData = device.RawDevice.Data;
var definitions = (Command.MappingType == MappingType.In) ? deviceData.MidiDefinitions.In.Definitions : deviceData.MidiDefinitions.Out.Definitions;
var bindings = deviceData.Mappings.MidiBindings.Bindings;
// remove old binding and definition(s) if no longer in use
if (MidiBinding != null)
{
// remove old binding and check if old definition can be removed too, because it is not used in another binding
var oldBinding = bindings.SingleOrDefault(b => b.BindingId.Equals(Id));
if (oldBinding != null)
{
bindings.Remove(oldBinding);
var oldBindings = bindings.Where(b => b.MidiNote.Equals(MidiBinding.Note));
if (!oldBindings.Any())
{
int removedCount = definitions.RemoveAll(d => d.MidiNote.Equals(MidiBinding.Note));
if (removedCount > 1)
{
// TODO: Something for the consolidation function
}
}
}
}
if (midi != null)
{
// add midi definition to device, if it doesn't already exist
var matchingDefinitions = definitions.Where(d => d.MidiNote.Equals(midi.Note));
if (matchingDefinitions.Any() == false)
{
var definition = midi.RawDefinition;
// adapt encoder mode to device, if necessary
var genericDefinition = midi as AGenericMidiDefinition;
if (genericDefinition != null) // && genericDefinition.MidiEncoderMode != device.EncoderMode)
{
genericDefinition = AGenericMidiDefinition.Parse(genericDefinition.Type, definition);
// genericDefinition.MidiEncoderMode = device.EncoderMode;
genericDefinition.MidiEncoderMode =
//this.MidiBinding.RawDefinition.MidiEncoderMode;
this.Command.RawSettings.EncoderMode2;
//genericDefinition.MidiEncoderMode = this.Command.Control.EncoderMode;
definition = genericDefinition.RawDefinition; // pestrela: this was unchanged
}
definitions.Add(definition);
}
else
{
// definition already exist. Update encoder
//matchingDefinitions.First().EncoderMode = this.MidiBinding.MidiEncoderMode;
}
// add midi binding to device
bindings.Add(new Format.MidiNoteBinding(Id, midi.Note));
}
// set midi binding to mapping
bool changed = (MidiBinding != null && !MidiBinding.Equals(midi)) || (midi != null && !midi.Equals(MidiBinding));
if (changed)
{
MidiBinding = midi;
}
return(changed);
}
private static Dictionary <string, AMidiDefinition> getDefinitionsFromTsi(MappingType type, string tsiFile)
{
Dictionary <string, AMidiDefinition> result = new Dictionary <string, AMidiDefinition>();
try
{
TsiFile file = TsiFile.Load(String.Empty, tsiFile);
if (type == MappingType.In)
{
result = file.Devices.SelectMany(dev =>
dev.RawDevice.Data.MidiDefinitions.In.Definitions.Select(def =>
AMidiDefinition.Parse(dev.TypeStr, MappingType.In, def))
).DistinctBy(m => m.Note).ToDictionary(k => k.Note, k => k);
}
else
{
result
= file.Devices.SelectMany(dev =>
dev.RawDevice.Data.MidiDefinitions.Out.Definitions.Select(def =>
AMidiDefinition.Parse(dev.TypeStr, MappingType.Out, def))
).DistinctBy(m => m.Note).ToDictionary(k => k.Note, k => k);
}
}
catch (Exception)
{
}
return(result);
}
// This is when we select a new Channel or Note
private void updateBinding(AMidiDefinition definition = null)
{
//if (_channel == "None")
// _channel = null; // this is to simplify the processing a lot
string expression;
AMidiDefinition tmpDefinition;
bool needs_cleanup = false;
foreach (var mapping in _mappings)
{
expression = null;
tmpDefinition = definition;
if (IsGenericMidi)
{
// special HACK follows
if (!String.IsNullOrEmpty(_note) && _note[0] == '_')
{
// remove the initial '_', but keep it for further processing
// the expression is already complete - doesn't need manipulations
expression = _note.Substring(1);
}
else if (!String.IsNullOrEmpty(_channel))
{
if (!String.IsNullOrEmpty(_note))
{
expression = _channel + "." + _note.Replace("+", "+" + _channel + ".");
}
else if (mapping.MidiBinding != null)
{
expression = Regex.Replace(mapping.MidiBinding.Note, @"Ch\d+", _channel);
}
}
else if (!String.IsNullOrEmpty(_note))
{
if (mapping.MidiBinding != null)
{
var channel = mapping.MidiBinding.Note.Substring(0, 4);
expression = channel + "." + _note.Replace("+", "+" + channel + ".");
}
}
if (expression != null)
{
tmpDefinition = AGenericMidiDefinition.Parse(mapping.Command.MappingType, expression);
}
}
else
{
if (tmpDefinition != null && mapping.Command.MappingType != tmpDefinition.Type)
{
tmpDefinition = _proprietaryDefinitions.First(p => p.Type == mapping.Command.MappingType && p.Note == tmpDefinition.Note);
}
}
mapping.SetBinding(tmpDefinition);
}
if (needs_cleanup)
{
_note = _note.Substring(6); //this is just to display correctly in the textbox
}
;
analyzeSelection();
updateMenus();
}
