comparison core.js @ 278:8020152a36af

Pull into main

 		this.popup.style.zIndex = 3;
 		this.popup.style.visibility = 'visible';
 		var blank = document.getElementsByClassName('testHalt')[0];
 		blank.style.zIndex = 2;
 		blank.style.visibility = 'visible';
+		$(window).keypress(function(e){
+			if (e.keyCode == 13 && popup.popup.style.visibility == 'visible')
+			{
+				// Enter key pressed
+				var textarea = $(popup.popupContent).find('textarea');
+				if (textarea.length != 0)
+				{
+					if (textarea[0] == document.activeElement)
+					{return;}
+				}
+				popup.buttonProceed.onclick();
+			}
+		});
 	};
 	
 	this.hidePopup = function(){
 		this.popup.style.zIndex = -1;
 		this.popup.style.visibility = 'hidden';

 			if (node.step != null) {input.step = node.step;}
 			this.popupContent.appendChild(input);
 		}
 		this.popupContent.appendChild(this.buttonProceed);
 		if(this.currentIndex+1 == this.popupOptions.length) {
-			this.buttonProceed.textContent = 'Submit';
+			if (this.responses.nodeName == "PRETEST") {
+				this.buttonProceed.textContent = 'Start';
+			} else {
+				this.buttonProceed.textContent = 'Submit';
+			}
 		} else {
 			this.buttonProceed.textContent = 'Next';
 		}
 		if(this.currentIndex > 0)
 			this.popupContent.appendChild(this.buttonPrevious);

 	 
 	// New check if we need to randomise the test order
 	if (specification.randomiseOrder)
 	{
  		specification.audioHolders = randomiseOrder(specification.audioHolders);
+ 		for (var i=0; i<specification.audioHolders.length; i++)
+ 		{
+ 			specification.audioHolders[i].presentedId = i;
+ 		}
 	}
 	
 	$(specification.audioHolders).each(function(index,elem){
 		testState.stateMap.push(elem);
 	});

 		};
 		xmlhttp.onreadystatechange  = function() {
 			console.log(xmlhttp.status);
 			if (xmlhttp.status != 200 && xmlhttp.readyState == 4) {
 				createProjectSave(null);
+			} else {
+				popup.showPopup();
+				popup.popupContent.innerHTML = null;
+				popup.popupContent.textContent = "Thank you for performing this listening test";
 			}
 		};
 		xmlhttp.send(file);
 	}
 }

 			if (this.audioObjectsReady == false) {
 				this.audioObjectsReady = this.checkAllReady();
 			}
 			if (this.audioObjectsReady == true) {
 				this.timer.startTest();
+				if (this.loopPlayback)
+					{this.setSynchronousLoop();}
 				this.status = 1;
 			}
 		}
 		if (this.status== 1) {
 			if (id == undefined) {

 				console.log('WAIT -- audioObject '+i+' not ready yet!');
 				ready = false;
 			};
 		}
 		return ready;
+	};
+	
+	this.setSynchronousLoop = function() {
+		// Pads the signals so they are all exactly the same length
+		if (this.audioObjectsReady)
+		{
+			var length = 0;
+			var lens = [];
+			var maxId;
+			for (var i=0; i<this.audioObjects.length; i++)
+			{
+				lens.push(this.audioObjects[i].buffer.length);
+				if (length < this.audioObjects[i].buffer.length)
+				{
+					length = this.audioObjects[i].buffer.length;
+					maxId = i;
+				}
+			}
+			// Perform difference
+			for (var i=0; i<lens.length; i++)
+			{
+				lens[i] = length - lens[i];
+			}
+			// Extract the audio and zero-pad
+			for (var i=0; i<lens.length; i++)
+			{
+				var orig = this.audioObjects[i].buffer;
+				var hold = audioContext.createBuffer(orig.numberOfChannels,length,orig.sampleRate);
+				for (var c=0; c<orig.numberOfChannels; c++)
+				{
+					var inData = hold.getChannelData(c);
+					var outData = orig.getChannelData(c);
+					for (var n=0; n<orig.length; n++)
+					{inData[n] = outData[n];}
+				}
+				this.audioObjects[i].buffer = hold;
+				delete orig;
+			}
+		}
 	};
 	
 }
 
 function audioObject(id) {

 		// Create callback to decode the data asynchronously
 		request.onloadend = function() {
 			audioContext.decodeAudioData(request.response, function(decodedData) {
 				audioObj.buffer = decodedData;
 				audioObj.state = 1;
+				if (audioObj.specification.type != 'outsidereference')
+					{audioObj.interfaceDOM.enable();}
 			}, function(){
 				// Should only be called if there was an error, but sometimes gets called continuously
 				// Check here if the error is genuine
 				if (audioObj.state == 0 || audioObj.buffer == undefined) {
 					// Genuine error

 		file.setAttribute('duration',this.buffer.duration);
 		root.appendChild(file);
 		if (this.specification.type != 'outsidereference') {
 			root.appendChild(this.interfaceDOM.exportXMLDOM(this));
 			root.appendChild(this.commentDOM.exportXMLDOM(this));
+			if(this.specification.type == 'anchor') {
+				root.setAttribute('anchor',true);
+			} else if(this.specification.type == 'reference') {
+				root.setAttribute('reference',true);
+			}
 		}
 		root.appendChild(this.metric.exportXMLDOM());
 		return root;
 	};
 }

 							this.max = Number(this.max);
 						}
 					}
 				} else if (this.type == 'anchor' || this.type == 'reference') {
 					this.value = Number(child.textContent);
+					this.enforce = child.getAttribute('enforce');
+					if (this.enforce == 'true') {this.enforce = true;}
+					else {this.enforce = false;}
 				}
 			};
 			this.options = [];
 			if (commonInterfaceNode != undefined) {
 				var child = commonInterfaceNode.firstElementChild;

 		this.enabled = name;
 	};
 	
 	this.audioHolderNode = function(parent,xml) {
 		this.type = 'audioHolder';
+		this.presentedId = parent.audioHolders.length;
 		this.interfaceNode = function(DOM) {
 			var title = DOM.getElementsByTagName('title');
 			if (title.length == 0) {this.title = null;}
 			else {this.title = title[0].textContent;}
 			this.options = parent.commonInterface.options;

 			else {this.reference = false;}
 			
 			this.marker = xml.getAttribute('marker');
 			if (this.marker == null) {this.marker = undefined;}
 			
-			if (this.anchor == true && this.marker == undefined) {
+			if (this.anchor == true) {
+				if (this.marker != undefined) {this.enforce = true;}
+				else {this.enforce = enforceAnchor;}
 				this.marker = anchor;
 			}
-			else if (this.reference == true && this.marker == undefined) {
+			else if (this.reference == true) {
+				if (this.marker != undefined) {this.enforce = true;}
+				else {this.enforce = enforceReference;}
 				this.marker = reference;
 			}
 			
 			if (this.marker != undefined) {
 				this.marker = Number(this.marker);

 		else {this.loop == false;}
 		if (xml.getAttribute('elementComments') == "true") {this.elementComments = true;}
 		else {this.elementComments = false;}
 		
 		var anchor = xml.getElementsByTagName('anchor');
+		var enforceAnchor = false;
 		if (anchor.length == 0) {
 			// Find anchor in commonInterface;
 			for (var i=0; i<parent.commonInterface.options.length; i++) {
 				if(parent.commonInterface.options[i].type == 'anchor') {
 					anchor = parent.commonInterface.options[i].value;
+					enforceAnchor = parent.commonInterface.options[i].enforce;
 					break;
 				}
 			}
 			if (typeof(anchor) == "object") {
 				anchor = null;

 		} else {
 			anchor = anchor[0].textContent;
 		}
 		
 		var reference = xml.getElementsByTagName('anchor');
+		var enforceReference = false;
 		if (reference.length == 0) {
 			// Find anchor in commonInterface;
 			for (var i=0; i<parent.commonInterface.options.length; i++) {
 				if(parent.commonInterface.options[i].type == 'reference') {
 					reference = parent.commonInterface.options[i].value;
+					enforceReference = parent.commonInterface.options[i].enforce;
 					break;
 				}
 			}
 			if (typeof(reference) == "object") {
 				reference = null;

 		
 		this.update = function() {
 			// Update the playhead position, startPlay must be called
 			if (this.timePerPixel > 0) {
 				var time = this.playbackObject.getCurrentPosition();
-				var width = 490;
-				var pix = Math.floor(time/this.timePerPixel);
-				this.scrubberHead.style.left = pix+'px';
-				if (this.maxTime > 60.0) {
-					var secs = time%60;
-					var mins = Math.floor((time-secs)/60);
-					secs = secs.toString();
-					secs = secs.substr(0,2);
-					mins = mins.toString();
-					this.curTimeSpan.textContent = mins+':'+secs;
+				if (time > 0) {
+					var width = 490;
+					var pix = Math.floor(time/this.timePerPixel);
+					this.scrubberHead.style.left = pix+'px';
+					if (this.maxTime > 60.0) {
+						var secs = time%60;
+						var mins = Math.floor((time-secs)/60);
+						secs = secs.toString();
+						secs = secs.substr(0,2);
+						mins = mins.toString();
+						this.curTimeSpan.textContent = mins+':'+secs;
+					} else {
+						time = time.toString();
+						this.curTimeSpan.textContent = time.substr(0,4);
+					}
 				} else {
-					time = time.toString();
-					this.curTimeSpan.textContent = time.substr(0,4);
+					this.scrubberHead.style.left = '0px';
+					if (this.maxTime < 60) {
+						this.curTimeSpan.textContent = '0.00';
+					} else {
+						this.curTimeSpan.textContent = '00:00';
+					}
 				}
 			}
 		};
 		
 		this.interval = undefined;
 		
 		this.start = function() {
 			if (this.playbackObject != undefined && this.interval == undefined) {
-				this.interval = setInterval(function(){interfaceContext.playhead.update();},100);
+				if (this.maxTime < 60) {
+					this.interval = setInterval(function(){interfaceContext.playhead.update();},10);
+				} else {
+					this.interval = setInterval(function(){interfaceContext.playhead.update();},100);
+				}
 			}
 		};
 		this.stop = function() {
 			clearInterval(this.interval);
 			this.interval = undefined;
+			if (this.maxTime < 60) {
+				this.curTimeSpan.textContent = '0.00';
+			} else {
+				this.curTimeSpan.textContent = '00:00';
+			}
 		};
 	};
 	
 	// Global Checkers
 	// These functions will help enforce the checkers

 	{
 		var audioHolder = testState.currentStateMap[testState.currentIndex];
 		if (audioHolder.anchorId != null)
 		{
 			var audioObject = audioEngineContext.audioObjects[audioHolder.anchorId];
-			if (audioObject.interfaceDOM.getValue() > audioObject.specification.marker)
+			if (audioObject.interfaceDOM.getValue() > audioObject.specification.marker && audioObject.interfaceDOM.enforce == true)
 			{
 				// Anchor is not set below
 				console.log('Anchor node not below marker value');
 				alert('Please keep listening');
 				return false;

 	{
 		var audioHolder = testState.currentStateMap[testState.currentIndex];
 		if (audioHolder.referenceId != null)
 		{
 			var audioObject = audioEngineContext.audioObjects[audioHolder.referenceId];
-			if (audioObject.interfaceDOM.getValue() < audioObject.specification.marker)
+			if (audioObject.interfaceDOM.getValue() < audioObject.specification.marker && audioObject.interfaceDOM.enforce == true)
 			{
 				// Anchor is not set below
 				console.log('Reference node not above marker value');
 				alert('Please keep listening');
 				return false;