comparison js/core.js @ 2678:e446c9b43cd9

#180. More JSHint corrections

     this.initialise = function () {
 
         // Get the data from Specification
         var pagePool = [];
         var pageInclude = [];
-        for (var page of specification.pages) {
+        for (var i = 0; i < specification.pages.length; i++) {
+            var page = specification.pages[i];
             if (page.alwaysInclude) {
                 pageInclude.push(page);
             } else {
                 pagePool.push(page);
             }

         var numPages = specification.poolSize;
         if (numPages > pagePool.length) {
             console.log("WARNING - You have specified more pages in <setup poolSize> than you have created!!");
             numPages = specification.pages.length;
         }
-        if (specification.poolSize == 0) {
+        if (specification.poolSize === 0) {
             numPages = specification.pages.length;
         }
         numPages -= pageInclude.length;
 
         if (numPages > 0) {

         }
         for (var i = 0; i < pageInclude.length; i++) {
             pageInclude[i].presentedId = i;
             this.stateMap.push(pageInclude[i]);
             // For each selected page, we must get the sub pool
-            if (pageInclude[i].poolSize != 0 && pageInclude[i].poolSize != pageInclude[i].audioElements.length) {
+            if (pageInclude[i].poolSize !== 0 && pageInclude[i].poolSize !== pageInclude[i].audioElements.length) {
                 var elemInclude = [];
                 var elemPool = [];
                 for (var elem of pageInclude[i].audioElements) {
                     if (elem.alwaysInclude || elem.type != "normal") {
                         elemInclude.push(elem);

             }
             storage.createTestPageStore(pageInclude[i]);
             audioEngineContext.loadPageData(pageInclude[i]);
         }
 
-        if (specification.preTest != null) {
+        if (specification.preTest !== null) {
             this.preTestSurvey = specification.preTest;
         }
-        if (specification.postTest != null) {
+        if (specification.postTest !== null) {
             this.postTestSurvey = specification.postTest;
         }
 
         if (this.stateMap.length > 0) {
-            if (this.stateIndex != null) {
+            if (this.stateIndex !== null) {
                 console.log('NOTE - State already initialise');
             }
             this.stateIndex = -2;
             console.log('Starting test...');
         } else {
             console.log('FATAL - StateMap not correctly constructed. EMPTY_STATE_MAP');
         }
     };
     this.advanceState = function () {
-        if (this.stateIndex == null) {
+        if (this.stateIndex === null) {
             this.initialise();
         }
         if (this.stateIndex > -2) {
             storage.update();
         }
         if (this.stateIndex == -2) {
             this.stateIndex++;
-            if (this.preTestSurvey != null) {
+            if (this.preTestSurvey !== null) {
                 popup.initState(this.preTestSurvey, storage.globalPreTest);
             } else {
                 this.advanceState();
             }
         } else if (this.stateIndex == -1) {

             }
         } else if (this.stateIndex == this.stateMap.length) {
             // All test pages complete, post test
             console.log('Ending test ...');
             this.stateIndex++;
-            if (this.postTestSurvey == null) {
+            if (this.postTestSurvey === null) {
                 this.advanceState();
             } else {
                 popup.initState(this.postTestSurvey, storage.globalPostTest);
             }
         } else if (this.stateIndex > this.stateMap.length) {
             createProjectSave(specification.projectReturn);
         } else {
             popup.hidePopup();
-            if (this.currentStateMap == null) {
+            if (this.currentStateMap === null) {
                 this.currentStateMap = this.stateMap[this.stateIndex];
                 // Find and extract the outside reference
                 var elements = [],
                     ref = [];
                 var elem;

                     elements = randomiseOrder(elements);
                 }
                 this.currentStateMap.audioElements = elements.concat(ref);
 
                 this.currentStore = storage.testPages[this.stateIndex];
-                if (this.currentStateMap.preTest != null) {
+                if (this.currentStateMap.preTest !== null) {
                     this.currentStatePosition = 'pre';
                     popup.initState(this.currentStateMap.preTest, storage.testPages[this.stateIndex].preTest);
                 } else {
                     this.currentStatePosition = 'test';
                 }

                     break;
                 case 'test':
                     this.currentStatePosition = 'post';
                     // Save the data
                     this.testPageCompleted();
-                    if (this.currentStateMap.postTest == null) {
+                    if (this.currentStateMap.postTest === null) {
                         this.advanceState();
                         return;
                     } else {
                         popup.initState(this.currentStateMap.postTest, storage.testPages[this.stateIndex].postTest);
                     }

                 case 'post':
                     this.stateIndex++;
                     this.currentStateMap = null;
                     this.advanceState();
                     break;
-            };
+            }
         }
     };
 
     this.testPageCompleted = function () {
         // Function called each time a test page has been completed

         if (this.stateIndex >= 0 && this.stateIndex < this.stateMap.length) {
             return this.currentStateMap;
         } else {
             return null;
         }
-    }
+    };
     this.getCurrentTestPageStore = function () {
         if (this.stateIndex >= 0 && this.stateIndex < this.stateMap.length) {
             return this.currentStore;
         } else {
             return null;
         }
-    }
+    };
 }
 
 function AudioEngine(specification) {
 
     // Create two output paths, the main outputGain and fooGain.

             if (this.status >= 2) {
                 this.status = 3;
             }
             for (var i = 0; i < this.users.length; i++) {
                 this.users[i].state = 1;
-                if (this.users[i].interfaceDOM != null) {
+                if (this.users[i].interfaceDOM !== null) {
                     this.users[i].bufferLoaded(this);
                 }
             }
         };
         this.setUrls = function (obj) {

                 if (urls[i].url == checkUrl) {
                     return true;
                 }
             }
             return false;
-        }
+        };
         this.getMedia = function () {
             var self = this;
             var currentUrlIndex = 0;
 
             function get(fqurl) {

                     self.status = 2;
                     calculateLoudness(self, "I");
                     return true;
                 }, function (e) {
                     var waveObj = new WAVE();
-                    if (waveObj.open(response) == 0) {
+                    if (waveObj.open(response) === 0) {
                         self.buffer = audioContext.createBuffer(waveObj.num_channels, waveObj.num_samples, waveObj.sample_rate);
                         for (var c = 0; c < waveObj.num_channels; c++) {
                             var buffer_ptr = self.buffer.getChannelData(c);
                             for (var n = 0; n < waveObj.num_samples; n++) {
                                 buffer_ptr[n] = waveObj.decoded_data[c][n];
                             }
                         }
-
-                        delete waveObj;
                     }
-                    if (self.buffer != undefined) {
+                    if (self.buffer !== undefined) {
                         self.status = 2;
                         calculateLoudness(self, "I");
                         return true;
                     }
+                    waveObj = undefined;
                     return false;
                 });
             }
 
             // Create callback for any error in loading
             function processError() {
                 this.status = -1;
                 for (var i = 0; i < this.users.length; i++) {
                     this.users[i].state = -1;
-                    if (this.users[i].interfaceDOM != null) {
+                    if (this.users[i].interfaceDOM !== null) {
                         this.users[i].bufferLoaded(this);
                     }
                 }
                 interfaceContext.lightbox.post("Error", "Could not load resource " + urls[currentUrlIndex].url);
             }
 
             function progressCallback(event) {
                 if (event.lengthComputable) {
                     this.progress = event.loaded / event.total;
                     for (var i = 0; i < this.users.length; i++) {
-                        if (this.users[i].interfaceDOM != null) {
+                        if (this.users[i].interfaceDOM !== null) {
                             if (typeof this.users[i].interfaceDOM.updateLoading === "function") {
                                 this.users[i].interfaceDOM.updateLoading(this.progress * 100);
                             }
                         }
                     }

             }
         };
 
         this.copyBuffer = function (preSilenceTime, postSilenceTime) {
             // Copies the entire bufferObj.
-            if (preSilenceTime == undefined) {
+            if (preSilenceTime === undefined) {
                 preSilenceTime = 0;
             }
-            if (postSilenceTime == undefined) {
+            if (postSilenceTime === undefined) {
                 postSilenceTime = 0;
             }
             var preSilenceSamples = secondsToSamples(preSilenceTime, this.buffer.sampleRate);
             var postSilenceSamples = secondsToSamples(postSilenceTime, this.buffer.sampleRate);
             var newLength = this.buffer.length + preSilenceSamples + postSilenceSamples;
             var copybuffer = audioContext.createBuffer(this.buffer.numberOfChannels, newLength, this.buffer.sampleRate);
             // Now we can use some efficient background copy schemes if we are just padding the end
-            if (preSilenceSamples == 0 && typeof copybuffer.copyToChannel == "function") {
+            if (preSilenceSamples === 0 && typeof copybuffer.copyToChannel === "function") {
                 for (var c = 0; c < this.buffer.numberOfChannels; c++) {
                     copybuffer.copyToChannel(this.buffer.getChannelData(c), c);
                 }
             } else {
                 for (var c = 0; c < this.buffer.numberOfChannels; c++) {

             }
             // Copy in the rest of the buffer information
             copybuffer.lufs = this.buffer.lufs;
             copybuffer.playbackGain = this.buffer.playbackGain;
             return copybuffer;
-        }
+        };
 
         this.cropBuffer = function (startTime, stopTime) {
             // Copy and return the cropped buffer
             var start_sample = Math.floor(startTime * this.buffer.sampleRate);
             var stop_sample = Math.floor(stopTime * this.buffer.sampleRate);

                     for (var n = 0; n < newLength; n++)
                         dst[n] = buffer[n + start_sample];
                 }
             }
             return copybuffer;
-        }
+        };
     };
 
     this.loadPageData = function (page) {
         // Load the URL from pages
         for (var element of page.audioElements) {

                 if (buffObj.hasUrl(URL)) {
                     buffer = buffObj;
                     break;
                 }
             }
-            if (buffer == null) {
+            if (buffer === null) {
                 buffer = new this.bufferObj();
                 var urls = [{
                     url: URL,
                     sampleRate: element.sampleRate
                 }];

         }
     };
 
     this.play = function (id) {
         // Start the timer and set the audioEngine state to playing (1)
-        if (this.status == 0) {
+        if (this.status === 0) {
             // Check if all audioObjects are ready
             this.bufferReady(id);
         } else {
             this.status = 1;
         }
-        if (this.status == 1) {
+        if (this.status === 1) {
             this.timer.startTest();
-            if (id == undefined) {
+            if (id === undefined) {
                 id = -1;
                 console.error('FATAL - Passed id was undefined - AudioEngineContext.play(id)');
                 return;
             } else {
                 interfaceContext.playhead.setTimePerPixel(this.audioObjects[id]);

             if (this.buffers[i].hasUrl(URL)) {
                 buffer = this.buffers[i];
                 break;
             }
         }
-        if (buffer == null) {
+        if (buffer === null) {
             console.log("[WARN]: Buffer was not loaded in pre-test! " + URL);
             buffer = new this.bufferObj();
             this.buffers.push(buffer);
             buffer.getMedia(URL);
         }

     };
 
     this.checkAllPlayed = function () {
         arr = [];
         for (var id = 0; id < this.audioObjects.length; id++) {
-            if (this.audioObjects[id].metric.wasListenedTo == false) {
+            if (this.audioObjects[id].metric.wasListenedTo === false) {
                 arr.push(this.audioObjects[id].id);
             }
         }
         return arr;
     };
 
     this.checkAllReady = function () {
         var ready = true;
         for (var i = 0; i < this.audioObjects.length; i++) {
-            if (this.audioObjects[i].state == 0) {
+            if (this.audioObjects[i].state === 0) {
                 // Track not ready
                 console.log('WAIT -- audioObject ' + i + ' not ready yet!');
                 ready = false;
-            };
+            }
         }
         return ready;
     };
 
     this.setSynchronousLoop = function () {

             }
             this.status = 1;
             return true;
         }
         return false;
-    }
+    };
 
     this.exportXML = function () {
 
     };
 

         // Called by the associated buffer when it has finished loading, will then 'bind' the buffer to the
         // audioObject and trigger the interfaceDOM.enable() function for user feedback
         if (callee.status == -1) {
             // ERROR
             this.state = -1;
-            if (this.interfaceDOM != null) {
+            if (this.interfaceDOM !== null) {
                 this.interfaceDOM.error();
             }
             this.buffer = callee;
             return;
         }

         var startTime = this.specification.startTime;
         var stopTime = this.specification.stopTime;
         var copybuffer = new callee.constructor();
 
         copybuffer.buffer = callee.cropBuffer(startTime || 0, stopTime || callee.buffer.duration);
-        if (preSilenceTime != 0 || postSilenceTime != 0) {
+        if (preSilenceTime !== 0 || postSilenceTime !== 0) {
             copybuffer.buffer = copybuffer.copyBuffer(preSilenceTime, postSilenceTime);
         }
 
         copybuffer.lufs = callee.buffer.lufs;
         this.buffer = copybuffer;

         if (typeof targetLUFS === "number" && isFinite(targetLUFS)) {
             this.buffer.buffer.playbackGain = decibelToLinear(targetLUFS - this.buffer.buffer.lufs);
         } else {
             this.buffer.buffer.playbackGain = 1.0;
         }
-        if (this.interfaceDOM != null) {
+        if (this.interfaceDOM !== null) {
             this.interfaceDOM.enable();
         }
         this.onplayGain = decibelToLinear(this.specification.gain) * (this.buffer.buffer.playbackGain || 1.0);
         this.storeDOM.setAttribute('playGain', linearToDecibel(this.onplayGain));
         this.state = 1;

         this.metric.startListening(audioEngineContext.timer.getTestTime());
         this.interfaceDOM.startPlayback();
     };
 
     this.loopStop = function (setTime) {
-        if (this.outputGain.gain.value != 0.0) {
+        if (this.outputGain.gain.value !== 0.0) {
             this.outputGain.gain.linearRampToValueAtTime(0.0, setTime);
             this.metric.stopListening(audioEngineContext.timer.getTestTime());
         }
         this.interfaceDOM.stopPlayback();
     };
 
     this.play = function (startTime) {
-        if (this.bufferNode == undefined && this.buffer.buffer != undefined) {
+        if (this.bufferNode === undefined && this.buffer.buffer !== undefined) {
             this.bufferNode = audioContext.createBufferSource();
             this.bufferNode.owner = this;
             this.bufferNode.connect(this.outputGain);
             this.bufferNode.buffer = this.buffer.buffer;
             this.bufferNode.loop = audioEngineContext.loopPlayback;
             this.bufferNode.onended = function (event) {
                 // Safari does not like using 'this' to reference the calling object!
                 //event.currentTarget.owner.metric.stopListening(audioEngineContext.timer.getTestTime(),event.currentTarget.owner.getCurrentPosition());
-                if (event.currentTarget != null) {
+                if (event.currentTarget !== null) {
                     event.currentTarget.owner.stop(audioContext.currentTime + 1);
                 }
             };
             this.outputGain.gain.cancelScheduledValues(audioContext.currentTime);
             if (!audioEngineContext.loopPlayback || !audioEngineContext.synchPlayback) {

         }
     };
 
     this.stop = function (stopTime) {
         this.outputGain.gain.cancelScheduledValues(audioContext.currentTime);
-        if (this.bufferNode != undefined) {
+        if (this.bufferNode !== undefined) {
             this.metric.stopListening(audioEngineContext.timer.getTestTime(), this.getCurrentPosition());
             this.bufferNode.stop(stopTime);
             this.bufferNode = undefined;
         }
         this.outputGain.gain.linearRampToValueAtTime(0.0, stopTime);
         this.interfaceDOM.stopPlayback();
     };
 
     this.getCurrentPosition = function () {
         var time = audioEngineContext.timer.getTestTime();
-        if (this.bufferNode != undefined) {
+        if (this.bufferNode !== undefined) {
             var position = (time - this.bufferNode.playbackStartTime) % this.buffer.buffer.duration;
             if (isNaN(position)) {
                 return 0;
             }
             return position;

         file.setAttribute('sampleCount', this.buffer.buffer.length);
         file.setAttribute('duration', this.buffer.buffer.duration);
         this.storeDOM.appendChild(file);
         if (this.specification.type != 'outside-reference') {
             var interfaceXML = this.interfaceDOM.exportXMLDOM(this);
-            if (interfaceXML != null) {
-                if (interfaceXML.length == undefined) {
+            if (interfaceXML !== null) {
+                if (interfaceXML.length === undefined) {
                     this.storeDOM.appendChild(interfaceXML);
                 } else {
                     for (var i = 0; i < interfaceXML.length; i++) {
                         this.storeDOM.appendChild(interfaceXML[i]);
                     }
                 }
             }
-            if (this.commentDOM != null) {
+            if (this.commentDOM !== null) {
                 this.storeDOM.appendChild(this.commentDOM.exportXMLDOM(this));
             }
         }
         var nodes = this.metric.exportXMLDOM();
         var mroot = this.storeDOM.getElementsByTagName('metric')[0];

     this.testStarted = false;
     this.testStartTime = 0;
     this.testDuration = 0;
     this.minimumTestTime = 0; // No minimum test time
     this.startTest = function () {
-        if (this.testStarted == false) {
+        if (this.testStarted === false) {
             this.testStartTime = audioContext.currentTime;
             this.testStarted = true;
             this.updateTestTime();
             audioEngineContext.metric.initialiseTest();
         }

         }
         this.movementTracker[this.movementTracker.length] = [time, position];
     };
 
     this.startListening = function (time) {
-        if (this.listenHold == false) {
+        if (this.listenHold === false) {
             this.wasListenedTo = true;
             this.listenStart = time;
             this.listenHold = true;
 
             var evnt = document.createElement('event');

             console.log('slider ' + this.parent.id + ' played (' + time + ')'); // DEBUG/SAFETY: show played slider id
         }
     };
 
     this.stopListening = function (time, bufferStopTime) {
-        if (this.listenHold == true) {
+        if (this.listenHold === true) {
             var diff = time - this.listenStart;
             this.listenedTimer += (diff);
             this.listenStart = 0;
             this.listenHold = false;
 
             var evnt = this.listenTracker[this.listenTracker.length - 1];
             var testTime = evnt.getElementsByTagName('testTime')[0];
             var bufferTime = evnt.getElementsByTagName('bufferTime')[0];
             testTime.setAttribute('stop', time);
-            if (bufferStopTime == undefined) {
+            if (bufferStopTime === undefined) {
                 bufferTime.setAttribute('stop', this.parent.getCurrentPosition());
             } else {
                 bufferTime.setAttribute('stop', bufferStopTime);
             }
             console.log('slider ' + this.parent.id + ' played for (' + diff + ')'); // DEBUG/SAFETY: show played slider id

             storeDOM.push(flagMoved);
         }
         if (audioEngineContext.metric.enableFlagComments) {
             var flagComments = storage.document.createElement('metricresult');
             flagComments.setAttribute('name', 'elementFlagComments');
-            if (this.parent.commentDOM == null) {
+            if (this.parent.commentDOM === null) {
                 flag.textContent = 'false';
-            } else if (this.parent.commentDOM.textContent.length == 0) {
+            } else if (this.parent.commentDOM.textContent.length === 0) {
                 flag.textContent = 'false';
             } else {
                 flag.textContet = 'true';
             }
             storeDOM.push(flagComments);

 
         hold.appendChild(date);
         hold.appendChild(time);
         return hold;
 
-    }
+    };
 
     this.lightbox = {
         parent: this,
         root: document.createElement("div"),
         content: document.createElement("div"),

             }
         },
         resize: function (event) {
             this.root.style.left = (window.innerWidth / 2) - 250 + 'px';
         }
-    }
+    };
 
     this.lightbox.root.appendChild(this.lightbox.content);
     this.lightbox.root.appendChild(this.lightbox.accept);
     this.lightbox.root.className = "popupHolder";
     this.lightbox.root.id = "lightbox-root";

                 inject.appendChild(box.trackComment);
             }
         };
 
         this.deleteCommentBoxes = function () {
-            if (this.injectPoint != null) {
+            if (this.injectPoint !== null) {
                 for (var box of this.boxes) {
                     this.injectPoint.removeChild(box.trackComment);
                 }
                 this.injectPoint = null;
             }
             this.boxes = [];
         };
-    }
+    };
 
     this.commentQuestions = [];
 
     this.commentBox = function (commentQuestion) {
         this.specification = commentQuestion;

             root.setAttribute('type', this.specification.type);
             var question = document.createElement('question');
             question.textContent = this.string.textContent;
             var response = document.createElement('response');
             var i = 0;
-            while (this.options[i].checked == false) {
+            while (this.options[i].checked === false) {
                 i++;
                 if (i >= this.options.length) {
                     break;
                 }
             }

             var text = text.firstChild;
             options.style.marginRight = spanMargin;
             options.style.marginLeft = spanMargin;
             text.style.marginRight = spanMargin;
             text.style.marginLeft = spanMargin;
-            while (options.nextSibling != undefined) {
+            while (options.nextSibling !== undefined) {
                 options = options.nextSibling;
                 text = text.nextSibling;
                 options.style.marginRight = spanMargin;
                 options.style.marginLeft = spanMargin;
                 text.style.marginRight = spanMargin;

             var text = text.firstChild;
             options.style.marginRight = spanMargin;
             options.style.marginLeft = spanMargin;
             text.style.marginRight = spanMargin;
             text.style.marginLeft = spanMargin;
-            while (options.nextSibling != undefined) {
+            while (options.nextSibling !== undefined) {
                 options = options.nextSibling;
                 text = text.nextSibling;
                 options.style.marginRight = spanMargin;
                 options.style.marginLeft = spanMargin;
                 text.style.marginRight = spanMargin;

         };
         this.error = function () {
             // audioObject has an error!!
             this.outsideReferenceHolder.textContent = "Error";
             this.outsideReferenceHolder.style.backgroundColor = "#F00";
-        }
-    }
+        };
+    };
 
     this.playhead = new function () {
         this.object = document.createElement('div');
         this.object.className = 'playhead';
         this.object.align = 'left';

         };
 
         this.interval = undefined;
 
         this.start = function () {
-            if (this.playbackObject != undefined && this.interval == undefined) {
+            if (this.playbackObject !== undefined && this.interval === undefined) {
                 if (this.maxTime < 60) {
                     this.interval = setInterval(function () {
                         interfaceContext.playhead.update();
                     }, 10);
                 } else {

         this.slider.onmousemove = function (event) {
             interfaceContext.volume.valueDB = event.currentTarget.value;
             interfaceContext.volume.valueLin = decibelToLinear(interfaceContext.volume.valueDB);
             interfaceContext.volume.valueText.textContent = interfaceContext.volume.valueDB + 'dB';
             audioEngineContext.outputGain.gain.value = interfaceContext.volume.valueLin;
-        }
+        };
         this.slider.onmouseup = function (event) {
             var storePoint = testState.currentStore.XMLDOM.getElementsByTagName('metric')[0].getAllElementsByName('volumeTracker');
-            if (storePoint.length == 0) {
+            if (storePoint.length === 0) {
                 storePoint = storage.document.createElement('metricresult');
                 storePoint.setAttribute('name', 'volumeTracker');
                 testState.currentStore.XMLDOM.getElementsByTagName('metric')[0].appendChild(storePoint);
             } else {
                 storePoint = storePoint[0];

             var node = storage.document.createElement('movement');
             node.setAttribute('test-time', audioEngineContext.timer.getTestTime());
             node.setAttribute('volume', interfaceContext.volume.valueDB);
             node.setAttribute('format', 'dBFS');
             storePoint.appendChild(node);
-        }
+        };
 
         var title = document.createElement('div');
         title.innerHTML = '<span>Master Volume Control</span>';
         title.style.fontSize = '0.75em';
         title.style.width = "100%";

         this.root.appendChild(this.slider);
         this.root.appendChild(this.valueText);
 
         this.resize = function (event) {
             if (window.innerWidth < 1000) {
-                this.object.className = "master-volume-holder-inline"
+                this.object.className = "master-volume-holder-inline";
             } else {
                 this.object.className = 'master-volume-holder-float';
             }
-        }
-    }
+        };
+    };
 
     this.calibrationModuleObject = null;
     this.calibrationModule = function () {
         // This creates an on-page calibration module
         this.storeDOM = storage.document.createElement("calibration");

                                 var value = Math.pow(10, this.input.value / 20);
                                 if (this.f == 1000) {
                                     audioEngineContext.outputGain.gain.value = value;
                                     interfaceContext.volume.slider.value = this.input.value;
                                 } else {
-                                    this.gain.gain.value = value
+                                    this.gain.gain.value = value;
                                 }
                                 break;
                         }
                     },
                     disconnect: function () {
                         this.gain.disconnect();
                     }
-                }
+                };
                 obj.root.className = "calibration-slider";
                 obj.root.appendChild(obj.input);
                 obj.oscillator.connect(obj.gain);
                 obj.gain.connect(audioEngineContext.outputGain);
                 obj.gain.gain.value = Math.random() * 2;

                 this.calibrationNodes.push(obj);
                 this.holder.appendChild(obj.root);
                 f0 *= 2;
             }
             inject.appendChild(this.holder);
-        }
+        };
         this.collect = function () {
             for (var obj of this.calibrationNodes) {
                 var node = storage.document.createElement("calibrationresult");
                 node.setAttribute("frequency", obj.f);
                 node.setAttribute("range-min", obj.input.min);
                 node.setAttribute("range-max", obj.input.max);
                 node.setAttribute("gain-lin", obj.gain.gain.value);
                 this.storeDOM.appendChild(node);
             }
-        }
-    }
+        };
+    };
 
 
     // Global Checkers
     // These functions will help enforce the checkers
     this.checkHiddenAnchor = function () {

                 if (delta >= time) {
                     passed = true;
                     break;
                 }
             }
-            if (passed == false) {
+            if (passed === false) {
                 check_pass = false;
                 console.log("Continue listening to track-" + object.interfaceDOM.getPresentedId());
                 error_obj.push(object.interfaceDOM.getPresentedId());
             }
         }
-        if (check_pass == false) {
+        if (check_pass === false) {
             var str_start = "You have not completely listened to fragments ";
             for (var i = 0; i < error_obj.length; i++) {
                 str_start += error_obj[i];
                 if (i != error_obj.length - 1) {
                     str_start += ', ';

     };
     this.checkAllMoved = function () {
         var str = "You have not moved ";
         var failed = [];
         for (var ao of audioEngineContext.audioObjects) {
-            if (ao.metric.wasMoved == false && ao.interfaceDOM.canMove() == true) {
+            if (ao.metric.wasMoved === false && ao.interfaceDOM.canMove() === true) {
                 failed.push(ao.interfaceDOM.getPresentedId());
             }
         }
-        if (failed.length == 0) {
+        if (failed.length === 0) {
             return true;
         } else if (failed.length == 1) {
             str += 'track ' + failed[0];
         } else {
             str += 'tracks ';

     };
     this.checkAllPlayed = function () {
         var str = "You have not played ";
         var failed = [];
         for (var ao of audioEngineContext.audioObjects) {
-            if (ao.metric.wasListenedTo == false) {
+            if (ao.metric.wasListenedTo === false) {
                 failed.push(ao.interfaceDOM.getPresentedId());
             }
         }
-        if (failed.length == 0) {
+        if (failed.length === 0) {
             return true;
         } else if (failed.length == 1) {
             str += 'track ' + failed[0];
         } else {
             str += 'tracks ';

                 this.storeErrorNode(str);
                 return false;
             }
         }
         return true;
-    }
+    };
     this.checkScaleRange = function (min, max) {
         var page = testState.getCurrentTestPage();
         var audioObjects = audioEngineContext.audioObjects;
         var state = true;
         var str = "Please keep listening. ";

         if (minRanking * 100 > min) {
             str += "At least one fragment must be below the " + min + " mark.";
             state = false;
         }
         if (maxRanking * 100 < max) {
-            str += "At least one fragment must be above the " + max + " mark."
+            str += "At least one fragment must be above the " + max + " mark.";
             state = false;
         }
         if (!state) {
             console.log(str);
             this.storeErrorNode(str);
             interfaceContext.lightbox.post("Error", str);
         }
         return state;
-    }
+    };
 
     this.storeErrorNode = function (errorMessage) {
         var time = audioEngineContext.timer.getTestTime();
         var node = storage.document.createElement('error');
         node.setAttribute('time', time);

                 case "letter":
                     return String.fromCharCode((index + offset) % 26 + 97);
                 case "capital":
                     return String.fromCharCode((index + offset) % 26 + 65);
                 case "samediff":
-                    if (index == 0) {
+                    if (index === 0) {
                         return "Same";
                     } else if (index == 1) {
                         return "Difference";
-                    } else {
-                        return "";
                     }
+                    return "";
                 case "number":
                     return String(index + offset);
                 default:
                     return "";
             }
         }
 
-        if (typeof labelStart !== "string" || labelStart.length == 0) {
+        if (typeof labelStart !== "string" || labelStart.length === 0) {
             labelStart = String.fromCharCode(0);
         }
 
         switch (labelType) {
             case "letter":

             }
             return a;
         } else {
             throw ("Invalid arguments");
         }
-    }
+    };
 
     this.getCombinedInterfaces = function (page) {
         // Combine the interfaces with the global interface nodes
         var global = specification.interfaces,
             local = page.interfaces;

                 // Use the global default scales
                 locInt.scales = global.scales;
             }
         });
         return local;
-    }
+    };
 }
 
 function Storage() {
     // Holds results in XML format until ready for collection
     this.globalPreTest = null;

     this.document = null;
     this.root = null;
     this.state = 0;
 
     this.initialise = function (existingStore) {
-        if (existingStore == undefined) {
+        if (existingStore === undefined) {
             // We need to get the sessionKey
             this.SessionKey.requestKey();
             this.document = document.implementation.createDocument(null, "waetresult", null);
             this.root = this.document.childNodes[0];
             var projectDocument = specification.projectXML;

         } else {
             this.document = existingStore;
             this.root = existingStore.firstChild;
             this.SessionKey.key = this.root.getAttribute("key");
         }
-        if (specification.preTest != undefined) {
+        if (specification.preTest !== undefined) {
             this.globalPreTest = new this.surveyNode(this, this.root, specification.preTest);
         }
-        if (specification.postTest != undefined) {
+        if (specification.postTest !== undefined) {
             this.globalPostTest = new this.surveyNode(this, this.root, specification.postTest);
         }
     };
 
     this.SessionKey = {

         request: new XMLHttpRequest(),
         parent: this,
         handleEvent: function () {
             var parse = new DOMParser();
             var xml = parse.parseFromString(this.request.response, "text/xml");
-            if (this.request.response.length == 0) {
+            if (this.request.response.length === 0) {
                 console.error("An unspecified error occured, no server key could be generated");
                 return;
             }
             if (xml.getElementsByTagName("state").length > 0) {
                 if (xml.getElementsByTagName("state")[0].textContent == "OK") {

             this.request.open("GET", returnURL + "php/requestKey.php", true);
             this.request.addEventListener("load", this);
             this.request.send();
         },
         update: function () {
-            if (this.key == null) {
+            if (this.key === null) {
                 console.log("Cannot save as key == null");
                 return;
             }
             this.parent.root.setAttribute("state", "update");
             var xmlhttp = new XMLHttpRequest();

                     } else {
                         var message = response.getElementsByTagName("message");
                         console.log("Intermediate save: Error! " + message.textContent);
                     }
                 }
-            }
+            };
             xmlhttp.send([hold.innerHTML]);
         }
-    }
+    };
 
     this.createTestPageStore = function (specification) {
         var store = new this.pageNode(this, specification);
         this.testPages.push(store);
         return this.testPages[this.testPages.length - 1];

             // ID is the position
             if (node.specification.type == 'statement') {
                 return;
             }
             var surveyresult = this.XMLDOM.firstChild;
-            while (surveyresult != null) {
+            while (surveyresult !== null) {
                 if (surveyresult.getAttribute("ref") == node.specification.id) {
                     break;
                 }
                 surveyresult = surveyresult.nextElementSibling;
             }

                         child.textContent = node.response.text;
                     }
                     surveyresult.appendChild(child);
                     break;
                 case "checkbox":
-                    if (node.response == undefined) {
+                    if (node.response === undefined) {
                         surveyresult.appendChild(this.parent.document.createElement('response'));
                         break;
                     }
                     for (var i = 0; i < node.response.length; i++) {
                         var checkNode = this.parent.document.createElement('response');

             }
         };
         this.complete = function () {
             this.state = "complete";
             this.XMLDOM.setAttribute("state", this.state);
-        }
+        };
     };
 
     this.pageNode = function (parent, specification) {
         // Create one store per test page
         this.specification = specification;

         this.state = "empty";
         this.XMLDOM = this.parent.document.createElement('page');
         this.XMLDOM.setAttribute('ref', specification.id);
         this.XMLDOM.setAttribute('presentedId', specification.presentedId);
         this.XMLDOM.setAttribute("state", this.state);
-        if (specification.preTest != undefined) {
+        if (specification.preTest !== undefined) {
             this.preTest = new this.parent.surveyNode(this.parent, this.XMLDOM, this.specification.preTest);
         }
-        if (specification.postTest != undefined) {
+        if (specification.postTest !== undefined) {
             this.postTest = new this.parent.surveyNode(this.parent, this.XMLDOM, this.specification.postTest);
         }
 
         // Add any page metrics
         var page_metric = this.parent.document.createElement('metric');

 
         // Add the audioelement
         for (var element of this.specification.audioElements) {
             var aeNode = this.parent.document.createElement('audioelement');
             aeNode.setAttribute('ref', element.id);
-            if (element.name != undefined) {
-                aeNode.setAttribute('name', element.name)
-            };
+            if (element.name !== undefined) {
+                aeNode.setAttribute('name', element.name);
+            }
             aeNode.setAttribute('type', element.type);
             aeNode.setAttribute('url', element.url);
             aeNode.setAttribute('fqurl', qualifyURL(element.url));
             aeNode.setAttribute('gain', element.gain);
             if (element.type == 'anchor' || element.type == 'reference') {

         this.parent.root.appendChild(this.XMLDOM);
 
         this.complete = function () {
             this.state = "complete";
             this.XMLDOM.setAttribute("state", "complete");
-        }
+        };
     };
     this.update = function () {
         this.SessionKey.update();
-    }
+    };
     this.finish = function () {
-        if (this.state == 0) {
+        if (this.state === 0) {
             this.update();
         }
         this.state = 1;
         this.root.setAttribute("state", "complete");
         return this.root;