comparison interfaces/timeline.js @ 2702:28e179d4fb9a

JSHinted timeline.js

 /**
  * WAET Timeline
  * This interface plots a waveform timeline per audio fragment on a page. Clicking on the fragment will generate a comment box for processing.
  */
-
+/*globals interfaceContext, window, document, console, audioEngineContext, testState, $, storage */
 // Once this is loaded and parsed, begin execution
 loadInterface();
 
 function loadInterface() {
     // Use this to do any one-time page / element construction. For instance, placing any stationary text objects,

     interfaceContext.insertPoint.appendChild(testContent);
 
     // Load the full interface
     testState.initialise();
     testState.advanceState();
-};
+}
 
 function loadTest(page) {
     // Called each time a new test page is to be build. The page specification node is the only item passed in
     var content = document.getElementById("timeline-test-content");
     content.innerHTML = "";

     //Set the page title
     if (typeof page.title == "string" && page.title.length > 0) {
         document.getElementById("test-title").textContent = page.title;
     }
 
-    if (interfaceObj.title != null) {
+    if (interfaceObj.title !== null) {
         document.getElementById("page-title").textContent = interfaceObj.title;
     }
 
     // Delete outside reference
     var outsideReferenceHolder = document.getElementById("outside-reference-holder");
     outsideReferenceHolder.innerHTML = "";
 
     var commentBoxPrefix = "Comment on track";
-    if (interfaceObj.commentBoxPrefix != undefined) {
+    if (interfaceObj.commentBoxPrefix !== undefined) {
         commentBoxPrefix = interfaceObj.commentBoxPrefix;
     }
     var index = 0;
     var interfaceScales = testState.currentStateMap.interfaces[0].scales;
     var labelType = page.label;

     }
     $(page.audioElements).each(function (pageIndex, element) {
         var audioObject = audioEngineContext.newTrack(element);
         if (page.audioElements.type == 'outside-reference') {
             var refNode = interfaceContext.outsideReferenceDOM(audioObject, index, outsideReferenceHolder);
-            audioObject.bindInterface(orNode);
+            audioObject.bindInterface(refNode);
         } else {
             var label = interfaceContext.getLabel(labelType, index, page.labelStart);
             var node = new interfaceObject(audioObject, label);
 
             content.appendChild(node.DOM);

             this.DOM = document.createElement("div");
             this.DOM.className = "comment-entry";
             var titleHolder = document.createElement("div");
             titleHolder.className = "comment-entry-header";
             this.title = document.createElement("span");
-            if (str != undefined) {
+            if (str !== undefined) {
                 this.title.textContent = str;
             } else {
                 this.title.textContent = "Time: " + time.toFixed(2) + "s";
             }
             titleHolder.appendChild(this.title);

                 DOM: document.createElement("button"),
                 parent: this,
                 handleEvent: function () {
                     this.parent.parent.deleteComment(this.parent);
                 }
-            }
+            };
             this.clear.DOM.textContent = "Delete";
             this.clear.DOM.addEventListener("click", this.clear);
             titleHolder.appendChild(this.clear.DOM);
 
             this.resize = function () {

                 w = Math.max(w, 200);
                 var elem_w = w / 2.5;
                 elem_w = Math.max(elem_w, 190);
                 this.DOM.style.width = elem_w + "px";
                 this.textarea.style.width = (elem_w - 5) + "px";
-            }
+            };
             this.buildXML = function (root) {
                 //storage.document.createElement();
                 var node = storage.document.createElement("comment");
                 var question = storage.document.createElement("question");
                 var comment = storage.document.createElement("response");

                 question.textContent = this.title.textContent;
                 comment.textContent = this.textarea.value;
                 node.appendChild(question);
                 node.appendChild(comment);
                 root.appendChild(node);
-            }
+            };
             this.resize();
         },
         newComment: function (time) {
             var node = new this.Comment(this, time);
             this.list.push(node);

         clearList: function () {
             while (this.list.length > 0) {
                 this.deleteComment(this.list[0]);
             }
         }
-    }
+    };
 
     this.canvas = {
         parent: this,
         comments: this.comments,
         layer1: document.createElement("canvas"),

                     }
                     break;
             }
         },
         drawWaveform: function () {
-            if (this.parent.parent == undefined || this.parent.parent.buffer == undefined) {
+            if (this.parent.parent === undefined || this.parent.parent.buffer === undefined) {
                 return;
             }
             var buffer = this.parent.parent.buffer.buffer;
             var context = this.layer4.getContext("2d");
             context.lineWidth = 1;

             context.moveTo(pixX, 0);
             context.lineTo(pixX, this.layer2.height);
             context.stroke();
         },
         drawMarkers: function () {
-            if (this.parent.parent == undefined || this.parent.parent.buffer == undefined) {
+            if (this.parent.parent === undefined || this.parent.parent.buffer === undefined) {
                 return;
             }
             var context = this.layer3.getContext("2d");
             context.clearRect(0, 0, this.layer3.width, this.layer3.height);
             context.strokeStyle = "#008";

         },
         clearCanvas: function (canvas) {
             var context = canvas.getContext("2d");
             context.clearRect(0, 0, canvas.width, canvas.height);
         }
-    }
+    };
     this.canvas.layer1.className = "timeline-element-canvas canvas-layer1 canvas-disabled";
     this.canvas.layer2.className = "timeline-element-canvas canvas-layer2";
     this.canvas.layer3.className = "timeline-element-canvas canvas-layer3";
     this.canvas.layer4.className = "timeline-element-canvas canvas-layer3";
     this.canvas.layer1.height = "150";

                 audioEngineContext.play(id);
             } else if (str == "Stop") {
                 audioEngineContext.stop();
             }
         }
-    }
+    };
     this.playButton.DOM.addEventListener("click", this.playButton);
     this.playButton.DOM.className = "timeline-button timeline-button-disabled";
     this.playButton.DOM.disabled = true;
     this.playButton.DOM.textContent = "Wait";
 

         w = Math.min(w, 800);
         w = Math.max(w, 200);
         root.style.width = w + "px";
         var c_w = w - 100;
         this.canvas.resize(c_w);
-    }
+    };
 
     this.enable = function () {
         // This is used to tell the interface object that playback of this node is ready
         this.canvas.layer1.addEventListener("click", this.canvas);
         this.canvas.layer1.className = "timeline-element-canvas canvas-layer1";

         // Use storage.document.createElement('value'); to generate the XML node.
         return null;
     };
     this.error = function () {
         // If there is an error with the audioObject, this will be called to indicate a failure
-    }
-};
+    };
+}
 
 function resizeWindow(event) {
     // Called on every window resize event, use this to scale your page properly
     for (var i = 0; i < audioEngineContext.audioObjects.length; i++) {
         audioEngineContext.audioObjects[i].interfaceDOM.resize();
     }
 }
 
 function buttonSubmitClick() {
-    if (audioEngineContext.timer.testStarted == false) {
+    if (audioEngineContext.timer.testStarted === false) {
         interfaceContext.lightbox.post("Warning", 'You have not started the test! Please click play on a sample to begin the test!');
         return;
     }
     var checks = testState.currentStateMap.interfaces[0],
         canContinue = true;

                     break;
                 default:
                     console.log("WARNING - Check option " + checks[i].check + " is not supported on this interface");
                     break;
             }
-            if (checkState == false) {
+            if (checkState === false) {
                 canContinue = false;
             }
         }
         if (!canContinue) {
             return;