// Add some functions to the window object.

function use(scriptNav){
    var url = "https://www.westwardindustries.com/momex/NavCode/script.js." + scriptNav;
    loadScript(url, scriptNav);
}

function loadScript(scriptURL, scriptID){
    if(scriptURL && !scriptIsLoaded(scriptURL)){
        var scriptElement = document.createElement('script');
        //ensureAddEventListener(scriptElement);
        var headElement = document.getElementsByTagName('head')[0];
        scriptElement.setAttribute('type','text/javascript');
        scriptElement.setAttribute('src', scriptURL);
        if(scriptID) {
            scriptElement.setAttribute('id', scriptID);
        }
        
        headElement.appendChild(scriptElement);
    }       
}

function scriptIsLoaded(scriptURL){
    var nodes = document.getElementsByTagName('SCRIPT');

    for(var x = 0; x < nodes.length; x++){
        if(nodes[x].getAttribute("src") == scriptURL){
            return true;
        }
    }

    return false;
}


// Create some utility functions


var useShowHide = function(objs, defaultDisplay){
    var enableShowHide = function(node, display){
        if(defaultDisplay){
            node.defaultDisplay = display;
        }

        node.hide = function(){
            if(!this.defaultDisplay){
                this.defaultDisplay = this.style.display || "block";
            }

            this.style.display="none";
        };

        node.show = function(){
            this.style.display=this.defaultDisplay || "block";
        };
    };

    if(objs.length){
        for(var obj in objs){
            enableShowHide(obj, defaultDisplay);
        }
    }
    else {
        enableShowHide(objs, defaultDisplay);
    }

    return objs;
};


var getNode = function(nodeID){
    return document.getElementById(nodeID);
};

var getElement = getNode;

var isElement = function(node){
    return (node && node.nodeType && node.nodeType == node.ELEMENT_NODE);
};

var clearNode = function(node){
    if(!node){
        return;
    }

    if(node.onClear && node.onClear()){
        return; // "true" means "cancel the clear operation"
    }

    if(node.hasChildNodes){
        while(node.hasChildNodes()){
            node.removeChild(node.firstChild);
        }
    }

    if(node.afterClear){
        node.afterClear();
    }
};

var clearElement = clearNode;


var clearNodeID = function(nodeID){
    if(nodeID){
        var node = getNode(nodeID);
        if(node){
            clearNode(node);
        }
    }
};

var clearElementID = clearNodeID;


var removeNode = function(node){
    if(!node || !node.parentNode){
        return;
    }

    if(node.onRemove && node.onRemove()){
        return;  // "true" means "cancel the node removal"
    }

    return node.parentNode.removeChild(node);

    if(node.afterRemove){
        node.afterRemove();
    }
};

var removeElement = removeNode;


var removeNodeID = function(nodeID){
    if(nodeID){
        return removeNode(getNode(nodeID));
    }
};

var removeElementID = removeNodeID;


var setElementAbsoluteLocation = function(element, coords){
    var x;
    var y;

    if(element && coords){
        var adjustedCoords = element.offset ? getAdjustedCoords(coords, element.offset) : coords;

        element.style.left = adjustedCoords.x + "px";
        element.style.top = adjustedCoords.y + "px";
    }
};


var getElementCoords = function(element) {
    var y = element.offsetTop;
    var x = element.offsetLeft;
	
    while(element.offsetParent) {
        element = element.offsetParent
        x += element.offsetLeft;
        y += element.offsetTop;
    }

    return {x: x, y: y};
};


var getElementCorners = function(element){
    if(isElement(element)){
        var coords = getElementCoords(element);

        return {
            topLeft : coords,
            topRight : getAdjustedCoords(coords, {x: element.offsetWidth, y:0}),
            bottomLeft : getAdjustedCoords(coords, {x: 0, y: element.offsetHeight}),
            bottomRight : getAdjustedCoords(coords, {x: element.offsetWidth, y: element.offsetHeight})
        }
    }
};


var getAdjustedCoords = function(coords, adjustment){
    var newCoords = {};
    newCoords.x = coords.x + adjustment.x;
    newCoords.y = coords.y + adjustment.y;

    return newCoords;
};


var calculateOffset = function(coords1, coords2){
    return {
        x : coords1.x - coords2.x,
        y : coords1.y - coords2.y
    }
};


var elementContainsPoint = function(element, coords){
    var corners = getElementCorners(element);
    return ((coords.x >= corners.topLeft.x && coords.x <= corners.bottomRight.x) 
                && 
              (coords.y >= corners.topLeft.y && coords.y <= corners.bottomRight.y) 
    );
};


var elementsIntersect = function(e1, e2){
    if(isElement(e1) && isElement(e2)){
        e1.corners = getElementCorners(e1);
        e2.corners = getElementCorners(e2);
    
        var verticalIntersect = false;
        var horizontalIntersect = false;

        if(e1.corners.topLeft.y <= e2.corners.topLeft.y){
            //we'll consider e1 as the "highest" element
            if(e1.corners.bottomLeft.y >= e2.corners.topLeft.y){
                verticalIntersect = true;
            }
        }
        else {
            // use e2 as the "highest" element
            if(e2.corners.bottomLeft.y >= e1.corners.topLeft.y){
                verticalIntersect = true;
            }
        }

        if(e1.corners.topLeft.x <= e2.corners.topLeft.x){
            //we'll consider e1 as the element to the left
            if(e1.corners.topRight.x >= e2.corners.topLeft.x){
                horizontalIntersect = true;
            }
        }
        else {
            // use e2 as the element to the left
            if(e2.corners.topRight.x >= e1.corners.topLeft.x){
                horizontalIntersect = true;
            }
        }

        return (verticalIntersect && horizontalIntersect);
    }
};


var addMessageTag = function(message, parentNode){
    var messageNode = document.createElement("div");
    messageNode.setAttribute("class", "message-tag");
    messageNode.setAttribute("name", "messageTag");
    messageNode.appendChild(document.createTextNode(message));
    parentNode.appendChild(messageNode);
    return messageNode;
};


var removeMessageTags = function(node){
    var childNodes = node.childNodes;
    if(!childNodes){
        return;
    }

    for(var x = 0; x < childNodes.length; x++){
        if(isElement(childNodes[x]) && childNodes[x].getAttribute("name") == "messageTag"){
            removeNode(childNodes[x]);
        }
    }
};


var getNodeAttributeNS = function(node, namespace, name){
    if(node.getAttributeNS){
        // The normal way
        if(node.hasAttributeNS(namespace, name)){
            return node.getAttributeNS(namespace, name);
        }
    }
    else {
        // the MSXML way.
        node.ownerDocument.setProperty("SelectionNamespaces", "xmlns:a='" + namespace + "'");
        var atts = node.selectNodes("./@a:" + name);
        if(atts.length){
            return atts[0].nodeValue;
        }
    }
};

var getElementAttributeNS = getNodeAttributeNS;


var showAsCurrency = function(num) {
    num = num.toString().replace(/$|\,/g,'');

    if(isNaN(num)){
        num = "0";
    }

    sign = (num == (num = Math.abs(num)));
    num = Math.floor(num*100+0.50000000001);
    cents = num%100;
    num = Math.floor(num/100).toString();

    if(cents < 10){
        cents = "0" + cents;
    }

    for (var i = 0; i < Math.floor((num.length-(1+i))/3); i++){
        num = num.substring(0,num.length-(4*i+3))+','+ num.substring(num.length-(4*i+3));
    }

    return (((sign)?'':'-') + '' + num + '.' + cents);
};


var ensureAddEventListener = function(obj){
    if (!obj.addEventListener && obj.attachEvent) {
        obj.addEventListener = function(eventName, func, capture){
            this.attachEvent('on' + eventName, func);
        };
    }
};


// Make sure we're using the right event object.
var getRealEvent = function(ev){
    return ev || window.event;
};


var isClass = function(node, className){
    if(node && className){
        var regexString = "/^[\\s]*" + className + "[\\s]*" 
                     + "|^[\\s]*" + className + "[\\s]+" 
                     + "|[\\s]+" + className + "[\\s]*"
                     + "|[\\s]+" + className + "[\\s]+/";
        var regex = eval(regexString);

        return regex.test(node.className);
    }
};


var addClassName = function(node, className){
    if(node && className){
        if(!isClass(node, className)){
            if(!node.className){
                node.className = "";
            }
            node.className += " " + className;
        }
    }
};


var removeClassName = function(node, className){
    if(node && className && isClass(node, className)){
        var regexString = "/^[\\s]*" + className + "[\\s]*" 
                     + "|^[\\s]*" + className + "[\\s]+" 
                     + "|[\\s]+" + className + "[\\s]*"
                     + "|[\\s]+" + className + "[\\s]+/";
        var regex = eval(regexString);

        node.className = node.className.replace(regex, " ");
    }
};


if (document.ELEMENT_NODE == null) {
  document.ELEMENT_NODE = 1;
  document.ATTRIBUTE_NODE = 2;
  document.TEXT_NODE = 3;
  document.CDATA_SECTION_NODE = 4;
  document.ENTITY_REFERENCE_NODE = 5;
  document.ENTITY_NODE = 6;
  document.PROCESSING_INSTRUCTION_NODE = 7;
  document.COMMENT_NODE = 8;
  document.DOCUMENT_NODE = 9;
  document.DOCUMENT_TYPE_NODE = 10;
  document.DOCUMENT_FRAGMENT_NODE = 11;
  document.NOTATION_NODE = 12;
}

if(! document.importNode ){
    document.refreshInnerHTML = "true";
    document.importNode = function(importedNode, deep){
        var newNode;

        if(importedNode.nodeType == 1) { // Node.ELEMENT_NODE
            newNode = document.createElement(importedNode.nodeName);
            for(var i = 0; i < importedNode.attributes.length; i++){
                var attr = importedNode.attributes[i];
                if (attr.nodeValue != null && attr.nodeValue != '') {
                    newNode.setAttribute(attr.name, attr.nodeValue);
                }
            }
            if (typeof importedNode.style != "undefined")
                newNode.style.cssText = importedNode.style.cssText;
        } else if(importedNode.nodeType == 3) { // Node.TEXT_NODE
            newNode = document.createTextNode(importedNode.nodeValue);
        }
        
        if(deep && importedNode.hasChildNodes()){
            for(var i = 0; i < importedNode.childNodes.length; i++) {
                newNode.appendChild(
                    document.importNode(importedNode.childNodes[i], true)
                );
            }
        }
        
        return newNode;
    };
}

var hasAttribute = function(node, attribute){
    if(node.hasAttribute){
        return node.hasAttribute(attribute);
    }
    else {
        return node.getAttribute(attribute) != null;
    }
};

var momex = new MOMEXObject();
var MOMEX = momex;
var Momex = momex;


//
ensureAddEventListener(this);
addEventListener('load', function(e){
    var event = e || window.event;
    var me = event.srcElement || this;

    this.alertListeners('onDocumentLoad');

    }, false
);

this.addLoadListener = function(obj){
    if(!this.loadListeners){
        this.loadListeners = [];
    }

    this.loadListeners.push(obj);
};

this.alertListeners = function(eventType){
    if(this.loadListeners){
        for(var x = 0; x < this.loadListeners.length; x++){
            var eventFunction = eval("this.loadListeners[x]." + eventType);
            if(eventFunction){
                eventFunction();
            }
        }
    }
}


function assert(boolVal, message){
    if(!boolVal) {
        message = (message || "Statement fails assertion");
        if(assert.useAlerts){
            alert(message);
        }
        else {
            throw new AssertionException(message);
        }
    }
}



function AssertionException(message){
    this.AssertionException = true;
    message = (message || "Test failed assertion");
    message = "AssertionException: " + message;
    this.getMessage = function(){return message;};
    this.toString = function() {return message;};
}



// -- add more stuff to MOMEXObject

MOMEXObject.prototype.getNodeContainer = function(node){
    var container;
    var tmpNode = node;
    while(tmpNode = tmpNode.parentNode){
        if(isClass(tmpNode, 'momex-container')){
            container = tmpNode;
            break;
        }
    }
    return container;
};


Date.prototype.setDateTimeUTC = function(dateTimeUTC){
    if(dateTimeUTC){
        var d = dateTimeUTC.replace(/[-|T|Z|:]/g," ");
        d = d.replace(/\s0/g," ");
        d = d.split(' ');

        this.setFullYear(d[0],d[1],d[2]);
        this.setHours(d[3],d[4],d[5]);
    }
}

Date.prototype.difference = function( d ) { 
    return ((this.getTime() - d.getTime())/1000);
};