312 lines
11 KiB
JavaScript
312 lines
11 KiB
JavaScript
(function (context, $) {
|
|
|
|
"use strict";
|
|
|
|
context.JK = context.JK || {};
|
|
context.JK.ConfigureTracksHelper2 = function (app) {
|
|
var logger = context.JK.logger;
|
|
var ASSIGNMENT = context.JK.ASSIGNMENT;
|
|
var VOICE_CHAT = context.JK.VOICE_CHAT;
|
|
var MAX_TRACKS = context.JK.MAX_TRACKS;
|
|
var MAX_OUTPUTS = context.JK.MAX_OUTPUTS;
|
|
var gearUtils = context.JK.GearUtils;
|
|
|
|
var $parent = null;
|
|
var $templateAssignablePort = null;
|
|
var $templateTrackTarget = null;
|
|
var $templateOutputTarget = null;
|
|
var $unassignedInputsHolder = null;
|
|
var $unassignedOutputsHolder = null;
|
|
var $tracksHolder = null;
|
|
var $outputChannelHolder = null;
|
|
var $instrumentsHolder = null;
|
|
var isDragging = false;
|
|
|
|
|
|
|
|
// inputChannelFilter is an optional argument that is used by the Gear Wizard.
|
|
// basically, if an input channel isn't in there, it's not going to be displayed
|
|
async function loadChannels(forceInputsToUnassign, inputChannelFilter) {
|
|
var musicPorts = await jamClient.FTUEGetChannels();
|
|
|
|
$unassignedInputsHolder.empty();
|
|
$unassignedOutputsHolder.empty();
|
|
|
|
var inputChannels = musicPorts.inputs;
|
|
var outputChannels = musicPorts.outputs;
|
|
|
|
// uncomment to add a bunch of bogus channels
|
|
//inputChannels = inputChannels.concat(inputChannels.concat(inputChannels.concat(inputChannels)))
|
|
|
|
context._.each(inputChannels, function (inputChannel) {
|
|
|
|
if(inputChannelFilter && !(inputChannelFilter.indexOf(inputChannel.id) > -1)) {
|
|
// skipping input channel because it's not in the filter
|
|
return;
|
|
}
|
|
|
|
var $channel = $(context._.template($templateAssignablePort.html(), $.extend({}, inputChannel, {direction:'in'}), { variable: 'data' }));
|
|
|
|
if(forceInputsToUnassign || inputChannel.assignment == ASSIGNMENT.UNASSIGNED) {
|
|
unassignInputChannel($channel);
|
|
}
|
|
else if(inputChannel.assignment == ASSIGNMENT.CHAT) {
|
|
// well, we can't show it as unused... if there were a place to show chat inputs, we would put it there.
|
|
// but we don't have it, so just skip
|
|
logger.debug("skipping chat channel ", inputChannel)
|
|
return;
|
|
}
|
|
else {
|
|
// find the track this belongs in
|
|
|
|
var trackNumber = inputChannel.assignment - 1;
|
|
|
|
// plop down a track holder on the UI
|
|
|
|
addChannelToTrack($channel, trackNumber);
|
|
}
|
|
})
|
|
|
|
var outputAssignment = 0;
|
|
context._.each(outputChannels, function (outputChannel, index) {
|
|
var $channel = $(context._.template($templateAssignablePort.html(), $.extend({}, outputChannel, {direction:'out'}), { variable: 'data' }));
|
|
|
|
|
|
|
|
if(outputChannel.assignment == ASSIGNMENT.UNASSIGNED) {
|
|
unassignOutputChannel($channel);
|
|
}
|
|
else {
|
|
var $output = $outputChannelHolder.find('.output[data-num="' + outputAssignment + '"]');
|
|
outputAssignment++;
|
|
|
|
if($output.length == 0) {
|
|
context.JK.alertSupportedNeeded('Unable to find an output holder for channel: ' + outputChannel.id + ' with assignment ' + outputChannel.assignment);
|
|
return false;
|
|
}
|
|
addChannelToOutput($channel, $output.find('.output-target'));
|
|
}
|
|
});
|
|
}
|
|
|
|
// iterates through the dom and returns a pure data structure for track associations and output channels
|
|
function getCurrentState() {
|
|
|
|
var state = {};
|
|
state.tracks = [];
|
|
state.unassignedChannels = [];
|
|
state.outputs = [];
|
|
var $unassignedInputChannels = $unassignedInputsHolder.find('.ftue-input');
|
|
var $unassignedOutputChannels = $unassignedOutputsHolder.find('.ftue-input');
|
|
var $tracks = $tracksHolder.find('.track-target');
|
|
var $outputs = $outputChannelHolder.find('.output-target');
|
|
|
|
context._.each($unassignedInputChannels, function($unassignedInput) {
|
|
$unassignedInput = $($unassignedInput);
|
|
var channelId = $unassignedInput.attr('data-input-id');
|
|
state.unassignedChannels.push(channelId);
|
|
})
|
|
|
|
context._.each($unassignedOutputChannels, function($unassignedOutput) {
|
|
$unassignedOutput = $($unassignedOutput);
|
|
var channelId = $unassignedOutput.attr('data-input-id');
|
|
state.unassignedChannels.push(channelId);
|
|
})
|
|
|
|
context._.each($tracks, function($track, index) {
|
|
$track = $($track);
|
|
var $assignedChannels = $track.find('.ftue-input');
|
|
|
|
var track = {index: index, channels:[]};
|
|
context._.each($assignedChannels, function($assignedChannel) {
|
|
$assignedChannel = $($assignedChannel);
|
|
track.channels.push($assignedChannel.attr('data-input-id'))
|
|
});
|
|
|
|
// sparse array
|
|
if(track.channels.length > 0) {
|
|
state.tracks.push(track);
|
|
}
|
|
var $instrument = $instrumentsHolder.find('[data-num="' + index + '"]').find('.icon-instrument-select');
|
|
track.instrument_id = $instrument.data('instrument_id');
|
|
})
|
|
|
|
context._.each($outputs, function($output, index) {
|
|
$output = $($output);
|
|
var $assignedChannel = $output.find('.ftue-input');
|
|
|
|
// this is overkill since there should only be 1 or 0 .ftue-inputs in a given .output
|
|
var outputSlot = {index: index, channels:[]};
|
|
context._.each($assignedChannel, function($assignedChannel) {
|
|
$assignedChannel = $($assignedChannel);
|
|
outputSlot.channels.push($assignedChannel.attr('data-input-id'))
|
|
});
|
|
|
|
// sparse array
|
|
if(outputSlot.channels.length > 0) {
|
|
state.outputs.push(outputSlot);
|
|
}
|
|
})
|
|
return state;
|
|
}
|
|
|
|
function validate(tracks) {
|
|
// there must be at least one assigned channel
|
|
if(tracks.tracks.length == 0) {
|
|
logger.debug("ConfigureTracks validation error: must have assigned at least one input port to a track.");
|
|
context.JK.Banner.showAlert('Must have assigned at least one input port to a track.');
|
|
return false;
|
|
}
|
|
|
|
// there must be some instruments
|
|
context._.each(tracks.tracks, function(track) {
|
|
if(!track.instrument_id) {
|
|
logger.debug("ConfigureTracks validation error: all tracks with ports assigned must specify an instrument.");
|
|
context.JK.Banner.showAlert('Please use the instrument icons to choose what you plan to play on each track.');
|
|
return false;
|
|
}
|
|
});
|
|
|
|
// there must be exactly 2 output channels assigned
|
|
if(tracks.outputs.length != 2 || (tracks.outputs[0].channels.length != 1 && track.outputs[1].channels.length != 1)) {
|
|
logger.debug("ConfigureTracks validation error: must have assigned exactly two output ports");
|
|
context.JK.Banner.showAlert('Must have assigned exactly 2 output ports.');
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
async function save(state) {
|
|
|
|
//context._.each(state.unassignedChannels, async function(unassignedChannelId) {
|
|
for (const unassignedChannelId of state.unassignedChannels) {
|
|
await context.jamClient.TrackSetAssignment(unassignedChannelId, true, ASSIGNMENT.UNASSIGNED);
|
|
}
|
|
//});
|
|
|
|
// save input/tracks
|
|
//context._.each(state.tracks, async function(track, index) {
|
|
for (let index = 0; index < state.tracks; index++) {
|
|
|
|
var track = state.tracks[index];
|
|
|
|
var trackNumber = index + 1;
|
|
|
|
//context._.each(track.channels, async function(channelId) {
|
|
for (const channelId of track.channels) {
|
|
await context.jamClient.TrackSetAssignment(channelId, true, trackNumber);
|
|
}
|
|
//});
|
|
logger.debug("context.jamClient.TrackSetInstrument(trackNumber, track.instrument_id)", trackNumber, track.instrument_id);
|
|
await context.jamClient.TrackSetInstrument(trackNumber, context.JK.instrument_id_to_instrument[track.instrument_id].client_id);
|
|
}
|
|
//});
|
|
|
|
// save outputs
|
|
//context._.each(state.outputs, async function(output, index) {
|
|
for(let index = 0; index < state.outputs.length; index++) {
|
|
let output = state.outputs[index];
|
|
//context._.each(output.channels, async function(channelId) {
|
|
for(const channelId of output.channels) {
|
|
await context.jamClient.TrackSetAssignment(channelId, true, ASSIGNMENT.OUTPUT);
|
|
}
|
|
//});
|
|
}
|
|
//});
|
|
|
|
var result = await context.jamClient.TrackSaveAssignments();
|
|
|
|
if(!result || result.length == 0) {
|
|
// success
|
|
return true;
|
|
}
|
|
else {
|
|
context.JK.Banner.showAlert('Unable to save assignments. ' + result);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async function loadTrackInstruments(forceInputsToUnassign) {
|
|
var $trackInstruments = $instrumentsHolder.find('.track-instrument');
|
|
|
|
//context._.each($trackInstruments, async function(trackInstrument) {
|
|
for(var i = 0; i < $trackInstruments.length; i++){
|
|
|
|
var trackInstrument = $trackInstruments[i];
|
|
|
|
var $trackInstrument = $(trackInstrument);
|
|
|
|
var trackIndex = parseInt($trackInstrument.attr('data-num')) + 1;
|
|
|
|
var clientInstrument = await context.jamClient.TrackGetInstrument(trackIndex);
|
|
|
|
var instrument = context.JK.client_to_server_instrument_map[clientInstrument];
|
|
|
|
$trackInstrument.instrumentSelectorSet(instrument ? instrument.server_id : instrument);
|
|
}
|
|
//});
|
|
|
|
}
|
|
|
|
function trySave() {
|
|
var state = getCurrentState();
|
|
|
|
if(!validate(state)) {
|
|
return false;
|
|
}
|
|
|
|
var saved = save(state);
|
|
|
|
if(saved) {
|
|
context.JK.GA.trackConfigureTracksCompletion(context.JK.detectOS());
|
|
}
|
|
|
|
return saved;
|
|
}
|
|
|
|
async function reset(forceInputsToUnassign, inputChannelFilter) {
|
|
loadChannels(forceInputsToUnassign, inputChannelFilter);
|
|
await loadTrackInstruments(forceInputsToUnassign);
|
|
}
|
|
|
|
function unassignOutputChannel($channel) {
|
|
var $originallyAssignedTrack = $channel.closest('.output-target');
|
|
$unassignedOutputsHolder.append($channel);
|
|
$originallyAssignedTrack.attr('output-count', $originallyAssignedTrack.find('.ftue-input:not(.ui-draggable-dragging)').length);
|
|
}
|
|
|
|
function unassignInputChannel($channel) {
|
|
var $originallyAssignedTrack = $channel.closest('.track-target');
|
|
$unassignedInputsHolder.append($channel);
|
|
$originallyAssignedTrack.attr('track-count', $originallyAssignedTrack.find('.ftue-input:not(.ui-draggable-dragging)').length);
|
|
|
|
}
|
|
|
|
function addChannelToTrack($channel, $track) {
|
|
var $originallyAssignedTrack = $channel.closest('.track-target');
|
|
$track.append($channel);
|
|
$track.attr('track-count', $track.find('.ftue-input:not(.ui-draggable-dragging)').length);
|
|
$originallyAssignedTrack.attr('track-count', $originallyAssignedTrack.find('.ftue-input:not(.ui-draggable-dragging)').length)
|
|
}
|
|
|
|
function addChannelToOutput($channel, $slot) {
|
|
var $originallyAssignedTrack = $channel.closest('.output-target');
|
|
$slot.append($channel);
|
|
$slot.attr('output-count', $slot.find('.ftue-input:not(.ui-draggable-dragging)').length);
|
|
$originallyAssignedTrack.attr('output-count', $originallyAssignedTrack.find('.ftue-input:not(.ui-draggable-dragging)').length)
|
|
}
|
|
|
|
function initialize(_$parent) {
|
|
$parent = _$parent;
|
|
|
|
}
|
|
|
|
this.initialize = initialize;
|
|
this.trySave = trySave;
|
|
this.reset = reset;
|
|
|
|
return this;
|
|
};
|
|
|
|
})(window, jQuery); |