SequenceMgr/SequenceMgr.js

/*
SEQUENCE GROUPING MANAGEMENT MODULE

this module builds a representation of a sequence in values using containers
It allows to create groups of keys, a group being a cue and one key per layer.
In a group, all keys sync their time on cue's time, only value can be modified

The sequence with grouping can then be exported and reloaded.

The module checks periodicaly if timeline sequence structure (cues, layers and keys) and
module values structure are in sync. If out of sync, you may either rebuild values structure 
from sequence or rebuild sequence from values

*/
var syncRatems = 100;
var syncDelta = 0.;
var doSync = false ;
var inibValuesChanged = false ;
var doSyncKeysCues = false ;

var saveFile = script.addFileParameter("auto save sequence","");
var saveRatems = 30;
var saveDelta = 0.;

var debug = true;
var debugFile;

var parametersPath = local.getChild("parameters") ;

var sequence = '' ;
var sequencePath = local.getChild("parameters").sequence ;
var file ;
var filePath = local.parameters.sequenceFile ;


var newGroupLayers = local.values.newGroup.layers ;
// var groups = local.getChild("values").groups ;
var cues = local.getChild("values").keys.cues ;
// var cuesList = []; //holds cues containers reference
var layers = local.getChild("values").keys.layers ;
// var layerList = {}; //holds layer container as object with reference and an array of keys containers references



var rebuildValues = script.addTrigger("rebuild values", "adds a key at current cursor position" );
var refreshKeys = script.addTrigger("refresh keys", "truc");
var TrigprintKeys = script.addTrigger("printKeys","truc");
var clearSeq = script.addTrigger("clear Sequence","truc");

var UIposGet = script.addTrigger("get UIPos", "");
var viewZoom = script.addFloatParameter("View Zoom", "", 0.5, 0., 1.); //part of sequence time to show
var viewFollowCursor = script.addBoolParameter("follow Cursor", "", false);
var followCursor = false ;
var followZoom = 0.5 ;
var followRatems = 1.;
var followDelta = 0.;

var prevKey = script.addTrigger("prev Key", "");
var nextKey = script.addTrigger("next Key", "");

var layerHeight = script.addFloatParameter("layer height", "", 70., 10., 150.); //part of sequence time to show
// var sequence_structure = {	params: {}, 
// 							groups:{},
// 							keys:{
// 								cues:{},
// 								layers:{}
// 							}
						// };
						 //WAS tl_groups
	/*group0 : { inCue : {pan : "key", tilt : "key", zoom : "key", dim : "key", focus : "key"},
							 							outCue : {pan : "key", tilt : "key", zoom : "key", dim : "key", focus : "key"}
													}*/
							
													


/////////////////////		SCRIPT FUNCTIONS	//////////////////////////////


function init() {
	script.log("LOADED SEQUENCE GROUPING MANAGEMENT MODULE ");
	
	//adapt update rate
	updateSyncRate();
	updateSynchronize();
	// script.log(root.sequences.truc.viewStartTime.get();)
	saveFile.set("sequence_autosave.json");
	saveFile.setAttribute("readonly", true);
	//importSequenceFile(saveFile);
	
	// var audioLayer = root.sequences.truc.layers.audio ;
	// var newClip = audioLayer.clips.addItem();
	// newClip.filePath.set("/home/titi/work/media/Sons/Mono/Aaaah.wav");
	// newClip.setName("testAudio");
	// newClip.startTime.set(12);

	printMethodsAndProperties(root.sequences.keys.layers.pan);
	// script.log(local.getChild("values").groups.group0.cue.get());

	//test if a sequence is already choosen else refresh and unlock sequence enum
	sequence = local.getChild("parameters").sequence.getKey();
	// var sequenceIndex = local.getChild("parameters").sequence.get();
	// script.log(sequenceIndex + "  " + sequence);
	
	if(sequence == ""){refreshSequenceEnum();}
	else{
		sequencePath.removeOptions();
		sequencePath.addOption(sequence,0);
		sequencePath.setAttribute("readonly", true);
	}
	sequence = local.getChild("parameters").sequence.getKey();

	seq_readZoomValue();

}

function scriptParameterChanged(param){
	
	if (param.is(TrigprintKeys) ){printKeys();}
	else if(param.is(viewZoom)) {
		script.log("view zoom changed");
		followZoom = param.get();
	}

	if (param.is(viewFollowCursor)){
		script.log("follow cursor " + (param.get() ? "ON" : "OFF"));
		followCursor = param.get();
	}

	else if(param.is(rebuildValues)){struct_updateValuesFromSeq();}

	else if (param.is(layerHeight)){seq_setLayerHeight();}

	else if (param.is(prevKey)){seq_prevNextCue(0);}
	else if (param.is(nextKey)){seq_prevNextCue(1);}

	else if (param.is(refreshKeys)){
		script.log("refreshKeys");
		refreshKeysList();
	}

	

	else {script.log("scriptparamchanged" + param.name);}
}



function update(deltaTime){
	if(sequence!=""){
		// script.log(doSync);
		if(doSync){
			syncDelta += deltaTime ;
			// script.log(doSync);
			if (syncDelta >= syncRatems){
				syncDelta = 0. ;
				var autosave = struct_updateValuesFromSeq();
				if(autosave){exportSequenceFile(saveFile);}
			}
		}	

		saveDelta += deltaTime ;
		if (saveDelta >= saveRatems){
			saveDelta = 0. ;
			exportSequenceFile(saveFile);
			script.log("sequence autosave");
		}

		followDelta += deltaTime ;
		if(followCursor && (followDelta>followRatems)){
			followDelta = 0. ;
			seq_followCursor() ;
		}
	}
	else{script.log("no sequence selected");}
}




///////////////////////////		HELPERS		/////////////////////////////////

function printMethodsAndProperties(obj){
	script.log(" ");
	// var name = obj.getControlAddress() == undefined ? "object" : obj.getControlAddress();
	var name = "object";
	script.log("  METHODS OF " + name);
	var methods = util.getObjectMethods(obj);
	for(var i=0 ; i<methods.length ; i++){
		script.log("  "+ methods[i]);
	}
	script.log("  PARAMETERS OF " + name);
	var props = util.getObjectProperties(obj, true, false);
	for(var i=0 ; i<props.length ; i++){
		script.log("  "+ props[i]);
	}
	script.log("  OBJECTS OF " + name);
	var props = util.getObjectProperties(obj, false, true);
	for(var i=0 ; i<props.length ; i++){
		script.log("  "+ props[i]);
	}
}


function printKeys(){

	var seq = root.sequences.sequence.layers.mapping.automation.getItems() ;
	if(seq.length){
		for(var i=0; i<seq.length; i++){
			script.log (">> "+seq[i].name + "  " + seq[i].position.get() + "  " + seq[i].listSize.get() );
		}
	}
	else{script.log("nothing to print");}
}




///////////////////////		 PARAMETERS FUNCTIONS	///////////////////////

// Module callback
function moduleParameterChanged(param){
	parametersPath = local.getChild("parameters") ;
	script.log("received module param :" + param.name);
	if (param.is(parametersPath.importExport.sequenceFile)) {}

	else if (param.is(parametersPath.importExport.importSequence)){importSequenceFile(parametersPath.importExport.sequenceFile);}
	
	else if (param.is(parametersPath.importExport.exportSequence)) { 
		exportSequenceFile(parametersPath.importExport.sequenceFile);
		exportSequenceFile(saveFile);
	}

	else if (param.is(parametersPath.synchronize)){updateSynchronize();}

	else if (param.is(parametersPath.syncRate)){updateSyncRate();}

	else if (param.is(parametersPath.monitorKeysCues)){monitorKeysCues();}

	else if (param.is(parametersPath.clearSequence)){seq_clearSequence();}

	else if (param.is(parametersPath.reorderSequence)){seq_reorderSequence();}

	else if (param.is(parametersPath.changeSequence)){refreshSequenceEnum();}

	else if (param.is(parametersPath.sequence)){
		sequence = sequencePath.getKey();
		if(sequence!=""){
			script.log("watching "+ sequence);
			local.parameters.sequence.setAttribute("readonly",true);

		}
		
	}

	else{script.log("received module param :" + param.name);}
}

function updateSynchronize(){
	// var parametersPath = local.getChild("parameters") ;
	doSync = parametersPath.synchronize.get();
	script.log(doSync ? "sync ON" : "sync OFF" );
}

function updateSyncRate(){
	// var parametersPath = local.getChild("parameters") ;
	syncRatems = parametersPath.syncRate.get() / 1000.;
	script.log("new sync rate : " + syncRatems);
	// script.setUpdateRate(syncRatems);
}

function monitorKeysCues(){
	// var parametersPath = local.getChild("parameters") ;
	doSyncKeysCues = parametersPath.monitorKeysCues.get() ;
	script.log(doSyncKeysCues ? "syncKeys ON" : "syncKeys OFF" );
	// script.setUpdateRate(syncRatems);
}

//refresh Enum
function refreshSequenceEnum(){
	script.log("refresh list of sequences");
	local.parameters.sequence.setAttribute("readonly",false);
	
	if(root.sequences.getItems().length){		
		local.parameters.sequence.removeOptions();
		local.parameters.sequence.addOption("", 0);
		for(var i=0 ; i<root.sequences.getItems().length ; i++ ){
			local.parameters.sequence.addOption(root.sequences.getItems()[i].name,i+1);
		}
	}

}

function importSequenceFile(loadFile){
	script.setExecutionTimeOut(60);
	doSync = false ;
	script.log("loading file "+loadFile.get());
	loadData = loadFile.readFile(true);

	//load parameters
	var parameters = local.getChild("parameters");
	parameters.syncRate.set(loadData.parameters['Sync Rate']);
	parameters.synchronize.set(loadData.parameters['Synchronize']);
	parameters.monitorKeysCues.set(loadData.parameters['monitorKeysCues']);
	sequence = loadData.parameters.Sequence;
	if(true){
		
		parameters.sequence.removeOptions();
		parameters.sequence.addOption(sequence,0);
		parameters.sequence.setAttribute("readonly", true);
		// script.log(parameters.synchronize.get());
		// 
		//check if Sequence already exists in sequences manager, else create it
		var tl_sequence = root.sequences.getItemWithName(sequence) ;
		if(tl_sequence == undefined){
			tl_sequence = root.sequences.addItem();
			tl_sequence.setName(sequence);
		}
		script.log(tl_sequence.name);
		//recreate cues
		tl_sequence.cues.removeAll();
		var cuesList = util.getObjectProperties(loadData.values.keys['cues'], false, true);
		script.log("create cues : "+ cuesList.length);
		if(cuesList.length){
			for(var i=0; i<cuesList.length; i++){
				var cue = tl_sequence.cues.addItem();
				cue.setName(cuesList[i]);
				cue.time.set(loadData.values.keys.cues[cuesList[i]]);
				script.log("created cue "+ cuesList[i]);
			}
		}

		//recreate layers and keys
		tl_sequence.layers.removeAll();
		printMethodsAndProperties(loadData.values.keys['layers']);
		var layersList = util.getObjectProperties(loadData.values.keys['layers'], true, false);
		script.log("create layers : "+ layersList.length);
		if(layersList.length){
			for(var i=0; i<layersList.length; i++ ){
				
				var layerType = loadData.values.keys.layers[layersList[i]].type ;
				var layer = tl_sequence.layers.addItem(layerType);
				script.log("create layer : ("+ layerType+") "+layersList[i]);
				layer.setName(layersList[i]);
				var keysList = util.getObjectProperties(loadData.values.keys.layers[layersList[i]], true, false);
				script.log("create keys : "+ keysList.length);
				if(keysList.length){
					if (layerType != "Audio"){
						for(var j=0; j<keysList.length; j++){						
							var key = layer.automation.addItem();
							key.setName(keysList[j]);
							key.value.set(loadData.values.keys.layers[layersList[i]][keysList[j]].value);
							key.position.set(loadData.values.keys.layers[layersList[i]][keysList[j]].time);
						}	
						layer.automation.reorderItems();	
					}
					else {
						for(var j=0; j<keysList.length; j++){						
							var clip = layer.clips.addItem();
							clip.setName(keysList[j]);
							clip.filePath.set(loadData.values.keys.layers[layersList[i]][keysList[j]].filePath);
							clip.startTime.set(loadData.values.keys.layers[layersList[i]][keysList[j]].startTime);
						}	
					}		
				}
				
			}
		}

		//recreate groups
		var groupList = util.getObjectProperties(loadData.values.groups, true, false);
		if(groupList.length){
			for(var i=0; i<groupList.length; i++){
				var group = local.getChild("Values").groups.addContainer(groupList[i]);
				var groupLayers = util.getObjectProperties(loadData.values.groups[groupList[i]], true, false);
				var cue = group.addFloatParameter("cue", "", 0., 0.);
				group.setName(groupList[i]);
				cue.set(loadData.values.groups[groupList[i]].time);
				if(loadData.values.groups[groupList[i]].timeOut!=undefined){
					var cueOut = group.addFloatParameter("cueOut", "", 0., 0.);
					cueOut.set(loadData.values.groups[groupList[i]].timeOut);
				}

				var groupKeysList = util.getObjectProperties(loadData.values.groups[groupList[i]].groupKeys, true, false);
				if (groupKeysList.length){
					var keysContainer = group.addContainer("keys");
					keysContainer.setCollapsed(true);
					var keysContainerOut ;
					if(loadData.values.groups[groupList[i]].timeOut!=undefined){
						keysContainerOut = group.addContainer("keysOut");
					}
					for (var j=0; j<groupKeysList.length; j++){
						group.addFloatParameter(groupKeysList[j], "", 0., 0., 1.);
						keysContainer.addStringParameter(groupKeysList[j], "", loadData.values.groups[groupList[i]]['groupKeys'][groupKeysList[j]]['key']);
						if(loadData.values.groups[groupList[i]].timeOut!=undefined){
							keysContainerOut.addStringParameter(groupKeysList[j], "", loadData.values.groups[groupList[i]]['groupKeys'][groupKeysList[j]]['key']+"o");
						}
					}
				}
			}
		}

		// script.log(layersList[0]);
		
		// updateSynchronize() ;
	}
	doSync = true;
	script.setExecutionTimeOut(5);

}

function exportSequenceFile(fileObj){
	script.log("exporting file");
	var exportData = {parameters:{}, values:{groups:{}, keys:{cues:{}, layers:{}}}};

	//collect parameters 
	var parameters = local.getChild("parameters");
	exportData.parameters["Sequence"] = parameters.sequence.getKey();
	exportData.parameters["Synchronize"] = parameters.synchronize.get();
	exportData.parameters["Sync Rate"] = parameters.syncRate.get();
	exportData.parameters["monitorKeysCues"] = parameters.monitorKeysCues.get();

	//collect values
	var values = local.getChild("values");

	//groups
	var groups = values.groups;
	var groupsList=util.getObjectProperties(groups, true, false);
	if(groupsList.length){
		for(var i=0; i<groupsList.length; i++){
			var exportGroup = exportData.values.groups[groupsList[i]] = {cue:"", time:0., groupKeys:{}};
			var currentGroup = groups.getChild(groupsList[i]);
			
			exportGroup.cue = currentGroup.name;
			exportGroup.time = currentGroup.cue.get();
			var isInOut = currentGroup.getChild("keysOut") ;
			if(isInOut){
				exportGroup.cueOut = currentGroup.name+"o";
				exportGroup.timeOut = currentGroup.cueOut.get();
			}

			var currentGroupLayers = util.getObjectProperties(currentGroup.keys, true, false);
			if (currentGroupLayers.length){
				for(var j=0; j<currentGroupLayers.length; j++){
					// script.log(groupsList[i]+ "  "+ currentGroupLayers[j]);
					exportGroup.groupKeys[currentGroupLayers[j]] = {key:"", value:0};
					exportGroup.groupKeys[currentGroupLayers[j]].value = currentGroup.getChild(currentGroupLayers[j]).get();
					exportGroup.groupKeys[currentGroupLayers[j]].key = currentGroup.keys.getChild(currentGroupLayers[j]).get();
				}
			}
		}
	}

	// var cues = values.keys.cues;
	// var cuesList=util.getObjectProperties(cues, true, false);
	// if(cuesList.length){
	// 	for(var i=0; i<cuesList.length; i++){
	// 		var exportCue = exportData.values.keys.cues[cuesList[i]] = {cue:"", time:0.};
	// 		exportCue.cue = cuesList[i];
	// 		exportCue.time = cues.getChild(cuesList[i]).time.get();
			
	// 	}
	// }

	// var layers = values.keys.layers;
	// var layersList=util.getObjectProperties(layers, true, false);
	// if(layersList.length){
	// 	for(var i=0; i<layersList.length; i++){
	// 		var exportLayer = exportData.values.keys.layers[layersList[i]] = {};
	// 		var currentLayer = layers.getChild(layersList[i]);
	// 		var currentLayersKeys = util.getObjectProperties(currentLayer, true, false);
	// 		exportLayer["type"] = values.keys.layerTypes.getChild(layersList[i]).get();
	// 		if (currentLayersKeys.length){
	// 			for(var j=0; j<currentLayersKeys.length; j++){
	// 				if (exportLayer["type"]!= "Audio"){
	// 					if(currentLayersKeys[j]!="type"){
	// 						// script.log(currentLayersKeys[j]);
	// 						// script.log(groupsList[i]+ "  "+ currentGroupLayers[j]);
	// 						exportLayer[currentLayersKeys[j]] = {key:"", value:0., time:0.};
	// 						exportLayer[currentLayersKeys[j]].value = currentLayer.getChild(currentLayersKeys[j]).value.get();
	// 						exportLayer[currentLayersKeys[j]].key = currentLayer.getChild(currentLayersKeys[j]).name;
	// 						exportLayer[currentLayersKeys[j]].time = currentLayer.getChild(currentLayersKeys[j]).time.get();
	// 					}
	// 				}
	// 				else {
	// 					exportLayer[currentLayersKeys[j]] = {clip:"", filePath:0., startTime:0.};
	// 					exportLayer[currentLayersKeys[j]].filePath = currentLayer.getChild(currentLayersKeys[j]).filePath.get();
	// 					exportLayer[currentLayersKeys[j]].clip = currentLayer.getChild(currentLayersKeys[j]).name;
	// 					exportLayer[currentLayersKeys[j]].startTime = currentLayer.getChild(currentLayersKeys[j]).startTime.get();
	// 				}
					
	// 			}
	// 		}
	// 	}
	// }

	//export cues and layers from tl
	var tl_seq = root.sequences.getItemWithName(sequence);
	var tl_cues = tl_seq.cues.getItems();
	if (tl_cues.length){
		for(var i=0; i<tl_cues.length; i++){
			exportData.values.keys.cues[tl_cues[i].name] = tl_cues[i].time.get();


		}
	}
	var tl_layers = tl_seq.layers.getItems();
	if (tl_layers.length){
		for(var i=0; i<tl_layers.length; i++){
			exportData.values.keys.layers[tl_layers[i].name] = {type:tl_layers[i].getType()};
			if(tl_layers[i].getType()=="Mapping"){
				var keys = tl_layers[i].automation.getItems();
				if(keys.length){
					for(var j=0; j<keys.length; j++){
						exportData.values.keys.layers[tl_layers[i].name][keys[j].name] = {value: keys[j].value.get(), time:keys[j].position.get()};

					}
				}
			}
			else if(tl_layers[i].getType()=="Audio"){
				var keys = tl_layers[i].clips.getItems();
				if(keys.length){
					for(var j=0; j<keys.length; j++){
						exportData.values.keys.layers[tl_layers[i].name][keys[j].name] = {filePath: keys[j].filePath.get(), startTime:keys[j].startTime.get()};

					}
				}
			}
			
		}
	}


	// exportData.groups
	fileObj.writeFile(JSON.stringify(exportData), true);
}




///////////////////////		 VALUES FUNCTIONS		///////////////////////
/* Values hold all keys, presented in group containers
a nogroup container shows keys that are not grouped
*/

// Value callback
function moduleValueChanged(value){
	if(!inibValuesChanged){
		doSync = false;

		//script.log(value.getParent().name);
		//here add actions for values that are also auto-updated, (groupKey values, times ets
		// they will prevent auto update while manipulated manually
		
		doSync = true;
	
	}

	if (value.is(local.values.newGroup.create)){createNewGroup();}
	if (value.is(local.values.newGroup.createInOut)){createNewGroup(1);}
	// script.log(value.getParent().name);
	// if(value.getParent().name = "cue"){script.log("changed");}
	// if (value.name == "addGroup"){createNewGroup();}
}


function struct_rebuildValues(){
	//build cues if needed
	var tl_cues = tl_seq.cues.getItems();
	cues = local.getChild("values").keys.cues ;
	var cuesList = util.getObjectProperties(cues, true, false);
	// script.log("cueList : " +cuesList.length);
	// script.log("tl List : " +tl_cues.length);
	if (cuesList.length != tl_cues.length){
		
		var delta = cuesList.length-tl_cues.length;
		var addRemove = delta > 0 ? false : true ; //0 to remove, 1 to add
		
		delta = Math.abs(delta);
		script.log("cues "+ delta + (addRemove ? " up" : " down"));
		for(var i=0; i<delta; i++){
			// script.log(i);
			if(addRemove){
				var newCue = cues.addContainer("newCue"+i);
				newCue.addFloatParameter("time", "position in time", 0., 0.);
				newCue.setCollapsed(true);
			}
			else {
				// script.log(util.getObjectProperties(cues, true, false)[0]);
				cues.removeContainer(util.getObjectProperties(cues, true, false)[i]);
			}
			// cuesList = ;
			
		}
		hasUpdated = true;
	}

	//update cues
	cues = local.getChild("values").keys.cues ;
	var cuesList = util.getObjectProperties(cues, true, false);
	if(tl_cues.length){
		for (var i=0; i<tl_cues.length; i++){
			var currentCue = cues.getChild(cuesList[i]);
			currentCue.setName(tl_cues[i].name);
			currentCue.time.set(tl_cues[i].time.get());
		}
	}

	
	//build layers if needed
	var layersChanged = false ;
	var tl_layers = tl_seq.layers.getItems();
	var layers = local.getChild("values").keys.layers ;
	var layersList = util.getObjectProperties(layers, true, false);
	if (layersList.length != tl_layers.length){
		layersChanged = true ;
		var delta = layersList.length-tl_layers.length;
		var addRemove = delta > 0 ? false : true ; //0 to remove, 1 to add
		delta = Math.abs(delta);
		script.log("layers "+ delta + (addRemove ? " up" : " down"));
		for(var i=0; i<delta; i++){
			// script.log(i);
			
			if(addRemove){
				var newLayer = layers.addContainer("newLayer"+i);
				// newLayer.addFloatParameter("time", "position in time", 0., 0.);
				local.getChild("values").keys.layerTypes.addStringParameter("newLayer"+i, "", "");
				newLayer.setCollapsed(true);
				local.getChild("values").newGroup.layers.addFloatParameter("newLayer"+i, "value for this layer at group creation", 0., 0., 1.);
				// if (tl_layers[i].getType()!="Audio"){
				// 	local.getChild("values").newGroup.layers.addFloatParameter("newLayer"+i, "value for this layer at group creation", 0., 0., 1.);
				// }
				
			}
			else {
				// script.log(util.getObjectProperties(layers, true, false)[0]);
				layers.removeContainer(util.getObjectProperties(layers, true, false)[i]);
				local.getChild("values").newGroup.layers.removeParameter(util.getObjectProperties(layers, true, false)[i]);
				local.getChild("values").newGroup.layers.setCollapsed(true);
				local.getChild("values").newGroup.layers.setCollapsed(false);
				local.getChild("values").keys.layerTypes.removeParameter(util.getObjectProperties(layers, true, false)[i]);
				local.getChild("values").keys.layerTypes.setCollapsed(true);
				local.getChild("values").keys.layerTypes.setCollapsed(false);
			}
			// cuesList = ;
			
		}
		hasUpdated = true;
	}
	//update layers value if there was a change in structure
	if(layersChanged){
		layers = local.getChild("values").keys.layers ;
		var layerList = util.getObjectProperties(layers, true, false);
		layerTypes = local.getChild("values").keys.layerTypes ;
		var layerTypeList = util.getObjectProperties(layerTypes, true, false);
		var template = local.getChild("values").newGroup.layers;
		var layerTemplate = util.getObjectProperties(template, true, false);

		if(tl_layers.length){
			var layer_offset = 0 ;
			for (var i=0; i<tl_layers.length; i++){
				var currentLayer = layers.getChild(layerList[i]);
				// currentLayer.getChild("type").set(tl_layers[i].getType());
				currentLayer.setName(tl_layers[i].name);
				var currentLayerType = layerTypes.getChild(layerTypeList[i]);
				currentLayerType.setName(tl_layers[i].name);
				currentLayerType.set(tl_layers[i].getType());
				var currentTemplate = template.getChild(layerTemplate[i]) ;
				if (tl_layers[i].getType()=="Audio"){layer_offset+=1;}
				currentTemplate.setName(tl_layers[i+layer_offset].name);
			}
		}
	}

	//build keys if needed
	layers = local.getChild("values").keys.layers ;
	layersList = util.getObjectProperties(layers, true, false);
	
	if(layersList.length){
		for(var layerIndex=0; layerIndex<layersList.length; layerIndex++){
			// script.log(layersList[layerIndex]);
			var currentLayer = layers.getChild(layersList[layerIndex]);
			var keyList = util.getObjectProperties(currentLayer, true, false);

			var tl_lay = tl_seq.layers.getItemWithName(layersList[layerIndex]);
			var tl_keys;
			
			//test keys for automation layers
			if(tl_lay.automation!=undefined){
				tl_keys = tl_lay.automation.getItems();
					//rebuild key structure for currentLayer
				if (keyList.length != tl_keys.length){
					var delta = keyList.length-tl_keys.length;
					var addRemove = delta > 0 ? false : true ; //0 to remove, 1 to add
					delta = Math.abs(delta);
					script.log("keys "+ delta + (addRemove ? " up" : " down"));
					for(var i=0; i<delta; i++){
						
						// script.log(i);
						if(addRemove){
							var newKey = currentLayer.addContainer("newkey"+i);
							newKey.addFloatParameter("time", "position in time", 0., 0.);
							newKey.addFloatParameter("value", "vertical value", 0., 0.);
							newKey.setCollapsed(true);
						}
						else {
							// script.log(util.getObjectProperties(currentLayer, true, false)[0]);
							currentLayer.removeContainer(util.getObjectProperties(currentLayer, true, false)[i]);
						}		
						
						
					}
					hasUpdated = true;
				}
			}
			

			//test clips for audio layer
			var tl_clips ;
			if(tl_lay.clips!=undefined){
				tl_clips = tl_lay.clips.getItems();
				//rebuild key structure for currentLayer, "keyList" holds clips
				if (keyList.length != tl_clips.length){
					var delta = keyList.length-tl_clips.length;
					var addRemove = delta > 0 ? false : true ; //0 to remove, 1 to add
					delta = Math.abs(delta);
					script.log("clips "+ delta + (addRemove ? " up" : " down"));
					for(var i=0; i<delta; i++){
						
						// script.log(i);
						if(addRemove){
							var newClip = currentLayer.addContainer("newclip"+i);
							newClip.addFileParameter("File Path", "sound file");
							newClip.addFloatParameter("start Time", "", 0., 0.);
							newClip.setCollapsed(true);
						}
						else {
							// script.log(util.getObjectProperties(currentLayer, true, false)[0]);
							currentLayer.removeContainer(util.getObjectProperties(currentLayer, true, false)[i]);
						}		
						
						
					}
					hasUpdated = true;
				}
			}
			


			currentLayer = layers.getChild(layersList[layerIndex]);
			keyList = util.getObjectProperties(currentLayer, true, false);
			//update values for currentLayer
			if(tl_keys.length){
				for(var i=0; i<tl_keys.length; i++){
					var currentKey = currentLayer.getChild(keyList[i]);
					currentKey.setName(tl_keys[i].name);
					currentKey.time.set(tl_keys[i].position.get());
					currentKey.value.set(tl_keys[i].value.get());

				}
			}
			if(tl_clips.length){
				for(var i=0; i<tl_clips.length; i++){
					var currentKey = currentLayer.getChild(keyList[i]);
					currentKey.setName(tl_clips[i].name);
					currentKey.filePath.set(tl_clips[i].filePath.get());
					currentKey.startTime.set(tl_clips[i].startTime.get());

				}
			}
		}
	}
}

function struct_rebuildGroupLayers(){
	var groupsUpdated = false;
	var tl_layers = tl_seq.layers.getItems();
	layers = local.getChild("values").newGroup.layers ;
	var layersList = util.getObjectProperties(layers, true, false);
	if (layersList.length != tl_layers.length){
		groupsUpdated = true;
		var delta = layersList.length-tl_layers.length;
		var addRemove = delta > 0 ? false : true ; //0 to remove, 1 to add
		delta = Math.abs(delta);
		script.log("Group layers "+ delta + (addRemove ? " up" : " down"));
		for(var i=0; i<delta; i++){
			// script.log(i);
			
			if(addRemove){

				local.getChild("values").newGroup.layers.addFloatParameter("newLayer"+i, "value for this layer at group creation", 0., 0., 1.);

				
			}
			else {

				local.getChild("values").newGroup.layers.removeParameter(util.getObjectProperties(layers, true, false)[i]);
				local.getChild("values").newGroup.layers.setCollapsed(true);
				local.getChild("values").newGroup.layers.setCollapsed(false);

			}
			// cuesList = ;
			
		}
		
	}
	
	var template = local.getChild("values").newGroup.layers;
	var layerTemplate = util.getObjectProperties(template, true, false);

	if (groupsUpdated){
		if(tl_layers.length){
			for (var i=0; i<tl_layers.length; i++){
				var currentTemplate = template.getChild(layerTemplate[i]) ;
				currentTemplate.setName(tl_layers[i].name);
				
			}
		}
	}
		
	
}

//rebuild values.keys structure from sequence
function struct_updateValuesFromSeq(){
	
	inibValuesChanged = true;
	var hasUpdated = false ;
	
	var tl_seq = root.sequences.getItemWithName(sequence);
	
	if(tl_seq.name!="undefined"){

		//Sync values structure
		if(doSyncKeysCues) {struct_rebuildValues();}

		else{struct_rebuildGroupLayers();}


		//Groups management
		tl_seq = root.sequences.getItemWithName(sequence);
		var groups = local.getChild("values").groups ;
		var groupList = util.getObjectProperties(groups, true, false);
		// printMethodsAndProperties(tl_seq.cues.getItemWithName("group0"));
		if(groupList.length){
			for (var i = 0; i<groupList.length; i++){
				//check if cue exist, else remove group
				// script.log(groupList[i]);

				//v1, remove cue doesn't remove group keys
				// var groupCue = tl_seq.cues.getItemWithName(groupList[i]);
				// if(groupCue.name==undefined){
				// 	script.log("cue " + groupList[i] + "not found, removing group (keys survive this)");
					
				// 	groups.removeContainer(groupList[i]);
				// 	hasUpdated = true;
				// 	break;
				// }

				//check if group has out
				var isInOut = groups.getChild(groupList[i]).getChild("keysOut") ;
				

				//v2, remove cue removes group keys
				var groupCue = tl_seq.cues.getItemWithName(groupList[i]);
				
				if(groupCue.name==undefined){
					script.log("cue " + groupList[i] + "not found, removing keys and group");
					if(isInOut){tl_seq.cues.removeItem(groupList[i]+"o");}
					var groupToRemove = groups.getChild(groupList[i]);
					var groupToRemoveKeyslist = util.getObjectProperties(groupToRemove.keys, true, false);
					for(var removeKeyIndex = 0; removeKeyIndex< groupToRemoveKeyslist.length; removeKeyIndex++) {
						var tl_removeLayer = tl_seq.layers.getItemWithName( groupToRemoveKeyslist[removeKeyIndex]) ;
						var tl_removeKey = tl_removeLayer.automation.getItemWithName(groupToRemove.keys.getChild( groupToRemoveKeyslist[removeKeyIndex]).get());
						// script.log(tl_removeKey.name);
						tl_removeLayer.automation.removeItem(tl_removeKey);
						var tl_removeKeyOut ;
						if(isInOut) {
							 tl_removeKeyOut = tl_removeLayer.automation.getItemWithName(groupToRemove.keys.getChild( groupToRemoveKeyslist[removeKeyIndex]).get()+"o");
							 tl_removeLayer.automation.removeItem(tl_removeKeyOut);
						}

					}
					groups.removeContainer(groupList[i]);
					hasUpdated = true;
					break;
				}

				//else check at key level
				else {
					groups = local.getChild("values").groups ;
					groupList = util.getObjectProperties(groups, true, false);
					var currentGroup = groups.getChild(groupList[i]);
					var currentGroupLayers = util.getObjectProperties (currentGroup.keys, true, false);
					//update cue time
					var groupTime = groupCue.time.get();			
					currentGroup.cue.set(groupTime);
					
					var groupCueOut;
					var groupTimeOut ;
					if(isInOut){
						groupCueOut = tl_seq.cues.getItemWithName(groupList[i]+"o");
						groupTimeOut = groupCueOut.time.get();
						currentGroup.cueOut.set(groupTimeOut);
					}

					if (currentGroupLayers.length){
						// script.log(currentGroupLayers.length);
						for(var j=0; j<currentGroupLayers.length; j++){
							// script.log("in loop" + j);
							groups = local.getChild("values").groups ;
							groupList = util.getObjectProperties(groups, true, false);
							currentGroup = groups.getChild(groupList[i]);
							currentGroupLayers = util.getObjectProperties (currentGroup.keys, true, false);
							var tl_layer = tl_seq.layers.getItemWithName(currentGroupLayers[j]);
							var keyName = currentGroup.keys.getChild(tl_layer.name).get();

							// script.log(tl_layer.name + "  " +tl_layer.automation.getItemWithName(keyName).name);
							//if key dosn't exist anymore, remove it from group
							// if(tl_layer.automation.getItemWithName(keyName).name == undefined){
							// 	groups = local.getChild("values").groups ;
							// 	groupList = util.getObjectProperties(groups, true, false);
							// 	currentGroup = groups.getChild(groupList[i]);
							// 	currentGroupLayers = util.getObjectProperties (currentGroup.keys, true, false);
							// 	tl_layer = tl_seq.layers.getItemWithName(currentGroupLayers[j]);
							// 	keyName = currentGroup.keys.getChild(tl_layer.name).get();
							// 	script.log("should remove" + currentGroup.name + "  " + currentGroupLayers[j]);
							// 	currentGroup.keys.removeParameter(currentGroupLayers[j]);
							// 	currentGroup.removeParameter(currentGroupLayers[j]);
							// 	currentGroup.setCollapsed(true);
							// 	currentGroup.setCollapsed(false);
							// 	hasUpdated = true;
								
							// }
							//if key exists, update value from tl and update time from group cue
							if(tl_layer.automation.getItemWithName(keyName).name != undefined){
								//apply groupTime
								var tl_key = tl_layer.automation.getItemWithName(keyName);
								tl_key.position.set(groupTime);
								//get tl value
								var keyValue = tl_key.value.get();
								
								var currentKey = currentGroup.getChild(tl_layer.name);
								// script.log(tl_layer.name + "  " +keyName+"  " + keyValue);
								// script.log(currentKey.name + "  " +keyName+"  " + keyValue);
								currentKey.set(keyValue);
								// script.log(currentKey.get());

								if(isInOut){
									
									var tl_keyOut = tl_layer.automation.getItemWithName(keyName+"o");
									tl_keyOut.position.set(groupTimeOut);
									//set keyOut value to keyIn value
									tl_keyOut.value.set(keyValue);
									
								}
							}
						}
					}
					// //if cue doesn't exist, remove whole group
					// if(tl_layers.length){
					// 	for (var j=0; j<tl_layers.length; j++){
					// 		if(!tl_layers[j].automation.getItemWithName(groupList[i])){
					// 			script.log("key " + groupList[i] + "not found, removing group (keys survive this)");
					// 			groups.removeContainer(groupList[i]);}
					// 			hasUpdated = true;
					// 	}
					// }

					//update group values
					
					
				}
			}
		}


		inibValuesChanged = false;
		return hasUpdated;
	}
	

}




// function rebuildValuesStructure() {
// 	script.log("updating values structure");
// 	//empty current structure 
// 	// local.values.removeAll();
// 	local.getChild("Values").removeContainer("newGroup");
// 	local.getChild("Values").removeContainer("groups");
// 	local.getChild("Values").removeContainer("ungrouped");

// 	//rebuild containers
// 	var ng_cont = local.values.addContainer("New group");
// 	var g_cont = local.values.addContainer("groups");
// 	var ug_cont = local.values.addContainer("ungrouped");
	
// 	// rebuild new group
// 	ng_cont.addTrigger("add group", "adds a new group at cursor time with below values");
// 	ng_cont.addFloatParameter("group time", "time position where the group will be created ", 0., 0.);
// 	var layer_cont = ng_cont.addContainer("layers values");
// 	var layers = util.getObjectProperties(sequence_structure.keys.layers) ;
// 	for (var i=0; i<layers.length; i++){
// 		//add a float value in each layer for group creation
// 		layer_cont.addFloatParameter(layers[i], "", 0., 0., 1.);
// 		ug_cont.addContainer(layers[i]);
// 	}

// 	//rebuild keys grouped/ungrouped
// 	//first create group containers in groups 

// 	// //then create layer containers in ungrouped
// 	// var layer_cont = ug_cont.addContainer("layers values");
	
// }




///////////////////////		TIMELINE FUNCTIONS		///////////////////////

function seq_clearSequence(){

	var seq = root.sequences.getItemWithName(sequence) ;
	script.log("clearing all keys and cues of sequence : "+seq.name);
	seq.cues.removeAll();
	var layers = seq.layers.getItems();
	if(layers.length){
		for (var i = 0; i<layers.length; i++){
			if(layers[i].automation){layers[i].automation.removeAll();}
			if(layers[i].clips){layers[i].clips.removeAll();}
		}
	}

	//clear all groups
	var groups = local.getChild("values").groups;
	var groupsList = util.getObjectProperties(groups, true, false);
	if (groupsList.length){
		for(var i=0; i<groupsList.length; i++){
			groups.removeContainer(groupsList[i]);
		}
	}
	
	

}


function seq_reorderSequence(){
	var seq = root.sequences.getItemWithName(sequence) ;
	script.log("reordering sequence : "+seq.name);
	var layers = seq.layers.getItems();
	if(layers.length){
		for (var i = 0; i<layers.length; i++){
			if(layers[i].automation){layers[i].automation.reorderItems();}
			if(layers[i].clips){layers[i].clips.reorderItems();}
		}
	}
}
//use Values structure to rebuild the sequence
function seq_buildSeqFromValues(){}

//use file to rebuild sequence
function seq_buildSeqFromFile(){}

function seq_MoveCurrentTime(deltaSeconds){
	var tl_seq = root.sequences.getItemWithName(sequence);
	var currentTime = tl_seq.currentTime.get();
	tl_seq.currentTime.set(currentTime + deltaSeconds);
}

function createNewGroup(isInOut){

	doSync = false ;

	script.log("create new group");
	//create a cue and a key in each layer at cursor position in selected sequence
	var groups = local.getChild("values").groups;
	var groupsList = util.getObjectProperties(groups, true, false);
	// printMethodsAndProperties(groupsList);
	// var index = groupsList.length == undefined ? 0 : groupsList.length;
	var currentGroup;

	var tl_seq = root.sequences.getItemWithName(sequence);
	var tl_layers = tl_seq.layers.getItems();
	script.log(groupList.length);

	//Get current sequence time position and create cue at this position, with group name
	var currentTime = tl_seq.currentTime.get() ;
	// var currentTime = local.values.newGroup.groupTime.get();
	// script.log(currentTime);
	var newCue = tl_seq.cues.addItem();
	newCue.time.set(currentTime);

	//test for holes in the sequence to rename the cue

	for (var i=0; i<=groupsList.length+1; i++){
		if(tl_seq.cues.getChild(i)==undefined){
			newCue.setName(i);
			currentGroup = groups.addContainer(i);
			currentGroup.setCollapsed(true);
			script.log("create new group: "+i);
			break;
		}
	}
 
	
	
	currentGroup.addFloatParameter("cue", "cue of the group", currentTime, 0.);
	var keysContainer = currentGroup.addContainer("keys");
	var keysOutContainer = 0 ;
	if (isInOut){
		var newCueOut = tl_seq.cues.addItem();
		newCueOut.time.set(currentTime+5);
		newCueOut.setName(currentGroup.name+"o");
		currentGroup.addFloatParameter("cueOut", "cue out of the group", currentTime + 5., 0.);
		keysOutContainer = currentGroup.addContainer("keysOut");
		keysOutContainer.setCollapsed(true);
	}
	keysContainer.setCollapsed(true);
	tl_seq = root.sequences.getItemWithName(sequence);
	tl_layers = tl_seq.layers.getItems();
	// var struc_layers = util.getObjectProperties(sequence_structure.keys.layers);
	if(tl_layers.length){
		for(var i=0;i<tl_layers.length; i++ ){
			if(tl_layers[i].automation!=undefined){//only for mapping layers    
				// script.log(sequence_structure.keys.layers[layers[i].name]);
				var newKeyValue = local.getChild("values").newGroup.layers.getChild(tl_layers[i].name).get();
				script.log(newKeyValue);
				var newKey = tl_layers[i].automation.addItem();
				newKey.position.set(currentTime);
				newKey.setName(currentGroup.name);
				// script.log(currentGroup.name);  //local.getChild("values").newGroup.layers.getChild().name
				newKey.value.set(newKeyValue);
				
				// newKey.value.set(Math.random());
				keysContainer.addStringParameter(tl_layers[i].name, "",currentGroup.name );
				currentGroup.addFloatParameter(tl_layers[i].name,tl_layers[i].name+" value" , currentGroup.name, 0., 1.);
				// newKey.addStringParameter("group", "key is part of this group","mongroupe");

				if (isInOut){
					var newKeyOut = tl_layers[i].automation.addItem();
					newKeyOut.position.set(currentTime+5.);
					newKeyOut.setName(currentGroup.name+"o");
					newKeyOut.value.set(newKeyValue);
					// newKey.value.set(Math.random());
					keysOutContainer.addStringParameter(tl_layers[i].name, "",currentGroup.name+"o" );						
				}

				tl_layers[i].automation.reorderItems();
			}
		}
	}
	doSync = true ;
	// seq = seq.getItems();

}


function seq_followCursor(){

	var tl_seq = root.sequences.getItemWithName(sequence);
	var tl_cursor = tl_seq.currentTime.get();
	var tl_totalTime = tl_seq.totalTime.get() ;
	var tl_startTime = tl_seq.viewStartTime.get();
	var tl_endTime = tl_seq.viewEndTime.get();

	//first check current viewTime and modify followZoom accordingly
	followZoom  = (tl_startTime - tl_endTime) / tl_totalTime;
	
	// if(viewZoom.get()!=followZoom && tl_startTime && (tl_endTime != tl_totalTime) ) {viewZoom.set(followZoom);script.log(viewZoom);}

	//then update view position 
	followZoom = viewZoom.get();
	var viewTime = followZoom * tl_totalTime ;
	var startTime = tl_cursor - viewTime/2. ;
	var endTime = tl_cursor + viewTime/2. ;

	tl_seq.viewStartTime.set(startTime);
	tl_seq.viewEndTime.set(endTime);
	
}

function seq_readZoomValue(){
	var tl_seq = root.sequences.getItemWithName(sequence);
	if(tl_seq != undefined){
		var tl_totalTime = tl_seq.totalTime.get() ;
		var tl_startTime = tl_seq.viewStartTime.get();
		var tl_endTime = tl_seq.viewEndTime.get();

		followZoom  = (tl_startTime - tl_endTime) / tl_totalTime;
		return followZoom ;
	}
	
}

function seq_setLayerHeight(){
	if(sequence!=""){
		var tl_seq = root.sequences.getItemWithName(sequence);
		var tl_layers = tl_seq.layers.getItems() ;
		if(tl_layers.length){
			var height = layerHeight.get();
			for(var i=0; i< tl_layers.length ; i++){
				tl_layers[i].uiHeight.set(height);
			}
		}

	}
}

function seq_prevNextCue(prevNext){
	//use first layer keys to navigate 
	if(sequence!=""){
		var tl_seq = root.sequences.getItemWithName(sequence);
		var tl_layer = tl_seq.layers.getItems()[0].automation;
		var tl_currentTime = tl_seq.currentTime.get() ;
		var currentKey = tl_layer.getKeyAtPosition(tl_currentTime);
		script.log(currentKey.name);
		var moveToKey ; 
		if(prevNext){ moveToKey = tl_layer.getItemAfter(currentKey);}
		else{moveToKey = tl_layer.getItemBefore(currentKey);}
		//if there is a key go there, else go to currentkey
		if(moveToKey!=undefined){tl_seq.currentTime.set(moveToKey.position.get());}
		else{tl_seq.currentTime.set(currentKey.position.get());}
		
	}
}