// Add some functions to the window object.

function use(scriptNav){
    var url = "http://truckdown.metrex.net/momex/NavCode/script.js." + scriptNav;
    loadScript(url, scriptNav);
}

function loadScript(scriptURL, scriptID){
    if(scriptURL && !scriptIsLoaded(scriptURL)){
        var scriptElement = document.createElement('script');
        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 getElementText = function(node){
    if(node && node.nodeType == document.ELEMENT_NODE){
        if(node.firstChild){
            return node.firstChild.nodeValue;
        }
    }
    return "";
};

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";
    }
};
setElementAbsoluteLocation.DEPRECATED = "use Momex.UI.setElementAbsoluteLocation in script.js.util.ui";


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};
};
getElementCoords.DEPRECATED = "use Momex.UI.getElementCoords in script.js.util.ui";



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})
        }
    }
};
getElementCorners.DEPRECATED = "use Momex.UI.getElementCorners in script.js.util.ui";

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

    return newCoords;
};
getAdjustedCoords.DEPRECATED = "use Momex.UI.getAdjustedCoords in script.js.util.ui";

var calculateOffset = function(coords1, coords2){
    return {
        x : coords1.x - coords2.x,
        y : coords1.y - coords2.y
    }
};
calculateOffset.DEPRECATED = "use Momex.UI.calculateOffset in script.js.util.ui";

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) 
    );
};
elementContainsPoint.DEPRECATED = "use Momex.UI.elementContainsPoint in script.js.util.ui";

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);
    }
};
elementsIntersect.DEPRECATED = "use Momex.UI.elementsIntersect in script.js.util.ui"

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;
};
addMessageTag.DEPRECATED = "use Momex.UI.addMessageTag in script.js.util.ui";

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]);
        }
    }
};
removeMessageTags.DEPRECATED = "use Momex.UI.removeMessageTags in script.js.util.ui";

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
               if ( importedNode.nodeName == "script" ) {
			eval(importedNode.text);
			return document.createTextNode('') ;
		}
            newNode = document.createElement(importedNode.nodeName);
            for(var i = 0; i < importedNode.attributes.length; i++){
                var attr = importedNode.attributes[i];
                newNode.setAttribute(attr.nodeName + '', attr.nodeValue + '');
                if ( attr.nodeName == 'enctype' && importedNode.nodeName == "form" ) { 
			newNode.setAttribute('ENCODING', attr.nodeValue + ''); 
		}
                if ( importedNode.nodeName == "form" || importedNode.nodeName == "select" || importedNode.nodeName == "input" || importedNode.nodeName == "textarea" ) { 
			var name = attr.nodeName + ''; 
			newNode.setAttribute(name.toUpperCase(), 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]-1,d[2]);
        this.setHours(d[3],d[4],d[5]);
    }
}

Date.prototype.parseISO8601 = function(dateToParse) {

    if (dateToParse && dateToParse.length > 1 && dateToParse.match(/^\d\d\d\d-?\d\d-?\d\d/)) {
        // separate date and time
        var dateTime = dateToParse.split("T");

        // set the date
        var dateArray = dateTime[0].split("-");
	this.setDate(1); // set day to a safe value such that set the month to February does not cause javascript to automatically set the month to March because the day is set to 29, 30 or 31.
        if (dateArray[0]) {
            this.setYear(dateArray[0]);
        }
        if (dateArray[1]) {
            this.setMonth(dateArray[1]-1);
        }
        if (dateArray[2]) {
            this.setDate(dateArray[2]);
        }

        // split time and offset
        var timeArray = null;
        if (dateTime[1]) {
//            timeArray = dateTime[1].match(/(\d\d):(\d\d):(\d\d)(?:\.\d+)?(?:([+-])(\d\d):(\d\d))?/);
            timeArray = dateTime[1].match(/(\d\d):?(\d\d):?(\d\d)(?:\.\d+)?(?:(Z)|(?:([+-])(\d\d):?(\d\d)?))?/);
        }

        if (timeArray) {
            // set the time
            if (timeArray[1]) {
                this.setHours(timeArray[1]);
            }
            if (timeArray[2]) {
                this.setMinutes(timeArray[2]);
            }
            if (timeArray[3]) {
                this.setSeconds(timeArray[3]);
            }

            // adjust the offset to +0000 if zulu
            if ( timeArray[4] == 'Z' ) {
                timeArray[5] = '+';
                //timeArray[6] = '0000';
                timeArray[6] = 0;
            }

            // add the offset
            if (timeArray[6] && timeArray[6].length == 2) {
                if ( timeArray[7] && timeArray[7].length == 2 ) {
                    timeArray[6] = (timeArray[6] * 60 * 60 * 1000 ) + ( timeArray[7] * 60 * 1000 );
                } else {
                    timeArray[6] = (timeArray[6] * 60 * 60 * 1000 );
                }
	    }

            if (timeArray[5] && ( timeArray[6] || timeArray[6] == 0 )) {
                var time = this.getTime() - (this.getTimezoneOffset() * 60000);
                if (timeArray[5] == "+") {
                    time -= timeArray[6];
                }
                else {
                    time += timeArray[6];
                }
                this.setTime(time);
            }
if (0) {
            if (timeArray[6] && timeArray[6].length == 2) {
                if ( timeArray[7] && timeArray[7].length == 2 ) {
                    timeArray[6] = '' + timeArray[6] + timeArray[7];
                } else {
                    timeArray[6] = '' + timeArray[6] + '00';
                }
	    }

            if (timeArray[5] && timeArray[6]) {
                var time = this.getTime() - this.getTimezoneOffset() * 60000;
                if (timeArray[5] == "+") {
                    time -= timeArray[6] * 3600000;
                }
                else {
                    time += timeArray[6] * 3600000;
                }
                this.setTime(time);
            }
}

        }
    }
};


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