/********************************/ // Dynamic Dependant Project /********************************/ // first, declare the two namespaces if they do not already exist var ddp; if(!ddp){ ddp = {};} /********************************/ // DDP /********************************/ ddp.f = {}; (function(){ var _memorize = {}; _memorize.elData = {}; _memorize.guidCounter = 0; var undef; //this will reliably always be undefined even if the global undefined variable is effed up by someone. //define DOM node type constants var nodeTypes = { ELEMENT_NODE : 1, ATTRIBUTE_NODE : 2, TEXT_NODE : 3, CDATA_SECTION_NODE : 4, ENTITY_REFERENCE_NODE : 5, ENTITY_NODE : 6, PROCESSING_INSTRUCTION_NODE : 7, COMMENT_NODE : 8, DOCUMENT_NODE : 9, DOCUMENT_TYPE_NODE : 10, DOCUMENT_FRAGMENT_NODE : 11, NOTATION_NODE : 12 }; /***************************************************************/ //if they don't exist, add the "forEach", "every" and "filter" methods to all Arrays using prototype //(these methods were added in Javascript 1.6, so IE7 and lower doesn't support them) if(!Array.prototype.forEach){ Array.prototype.forEach = function(fn, thisObj){ var scope = thisObj || window; for( var i=0, j=this.length; i < j; ++i ){ fn.call(scope, this[i], i, this); } }; } if(!Array.prototype.every){ Array.prototype.every = function(fn, thisObj){ var scope = thisObj || window; for( var i=0, j=this.length; i < j; ++i ){ if(i in this && !fn.call(scope, this[i], i, this)){ return false; } } return true; }; } if(!Array.prototype.filter){ Array.prototype.filter = function(fn, thisObj){ var scope = thisObj || window; var a = []; for( var i=0, j=this.length; i < j; ++i ){ if( !fn.call(scope, this[i], i, this) ){ continue; } a.push(this[i]); } return a; }; } //Replaces: document.getElementById() //Takes strings and objects //var elements = ddp.f.$('id',objname); function $() { var elements = []; for(var i=0, l=arguments.length; i element addEvent(document, 'ready', function(){ document.getElementsByTagName('head')[0].appendChild(elNewScript); }); } /***************************************************************/ //makeRealArray //takes an object with 'length' property and returns an actual array //(useful for 'arguments' and objects returned from getElementsByTagName(), etc..) function makeRealArray(objObject){ //can't get this approach to work in ie (DOM nodelists throw a "Jscript object expected" error) //return Array.prototype.slice.call(objObject, 0); //return [].slice.call(objObject, 0); var arReturn = []; var i=objObject.length, l=i-1; //fills in the array elements backwards... while(i--){ arReturn[l-i]=objObject[l-i]; } return arReturn; } /***************************************************************/ //randomSortArray //randomly sorts the elements of an array function randomSortArray(arToSort){ arToSort.sort(function(){return (Math.round(Math.random())-0.5);}); return arToSort; } /***************************************************************/ //isArray //tests for arrays function isArray(varTest){ if(varTest === null){ return false; } if(typeof varTest == 'object' && typeof varTest.constructor == 'function' && typeof varTest.length == 'number' ){ //return (varTest.constructor.toString().match(/function array/i) !== null); return !!varTest.constructor.toString().match(/function array/i); } return false; } /***************************************************************/ //isString //tests for strings and string objects function isString(varTest){ if(varTest === null){ return false; } if(typeof varTest == 'string'){ return true; } if(typeof varTest == 'object' && typeof varTest.constructor == 'function'){ //return (varTest.constructor.toString().match(/string/i) != null); return !!varTest.constructor.toString().match(/string/i); } return false; } /***************************************************************/ //isObject //tests for objects which are not strings or arrays (and not null) function isObject(varTest){ //it's not null, has typeof "object", isn't a string, isn't an array, and isn't a function return (varTest !== null && typeof varTest == 'object' && !isString(varTest) && !isArray(varTest) && !isFunction(varTest)); } /***************************************************************/ //isFunction //tests for objects which are not strings or arrays (and not null) function isFunction(varTest){ if(!varTest){ return false; } if(typeof varTest == 'function'){ return true; } //ie6's stupid broken return value for functions across windows is "object" if(typeof varTest == 'object' && typeof varTest.constructor == 'object'){ //return (varTest.constructor.toString().match(/function Function/) != null); return !!varTest.constructor.toString().match(/function Function/); } return false; } function isDate(varTest){ return !!(varTest && varTest.constructor && varTest.constructor.toString().match(/Date/)); } /***************************************************************/ //cloneObject //makes a "copy" of the object passed to it. (actually creates a new object and copies the old object's properties into it) //optional parameter "onlyOwnProperties", if set to true, only copies properties not inherited through it's prototype function cloneObject(objToClone, allProperties, blnDeepClone){ var objNew = {}; //iterate through the object's properties for(var key in objToClone){ //if "hasOwnProperties" has been passed in as "true", then check to see if the property in question belongs to the object if(!allProperties){ if(objToClone.hasOwnProperty){ if(!objToClone.hasOwnProperty(key)){ continue; } } else{ if(objToClone.prototype && typeof objToClone.prototype[key] != 'undefined'){ continue; } } } if(blnDeepClone && isObject(objToClone[key])){ objNew[key] = cloneObject(objToClone[key]); } else{ //copy the reference or data to the new object objNew[key] = objToClone[key]; } } //return the new object return objNew; } /***************************************************************/ //arrayCompare //tests to see if two arrays are identical function arrayCompare(ar1, ar2){ var i = ar1.length; if(i != ar2.length){ return false; } while(i--){ if(ar1[i] !== ar2[i]){ return false; } } return true; } /***************************************************************/ function obsEvent() { this.fns = []; } obsEvent.prototype = { subscribe : function(fn) { this.fns.push(fn); }, unsubscribe : function(fn) { this.fns = this.fns.filter( function(el) { if ( el !== fn ) { return el; } } ); }, fire : function(o, thisObj) { var scope = thisObj || window; this.fns.forEach( function(el) { el.call(scope, o); } ); } }; /***************************************************************/ function mousePosition(objEvent){ //make sure we have the event object objEvent = objEvent || window.event; try{ if(objEvent.pageX || objEvent.pageY){ return {x:objEvent.pageX, y:objEvent.pageY}; } return { x: objEvent.clientX + document.body.scrollLeft - document.body.clientLeft, y: objEvent.clientY + document.body.scrollTop - document.body.clientTop }; } catch(e){ //in IE6 if this method is executed before the page fully loads, it throws an error... return {x:0,y:0}; } } /***************************************************************/ //replace anything other than a numerical digit with nothing function removeAlpha(torem) { return torem.replace(/\D/g,''); } /***************************************************************/ //replace anything other than an ASCII word character with nothing function removeNonAsciiWord(torem){ return torem.replace(/\W/g,''); } /***************************************************************/ //verify a valid phone number function checkValidPhoneNumber(phoneNo){ var phoneRE = /^(\(?[0-9]{3}\)?)?\-?[0-9]{3}\-?[0-9]{4}$/; //return (phoneNo.match(phoneRE) == true); //change for jslint return (phoneNo.match(phoneRE) !== null); } /***************************************************************/ //verify a valid email address where the address is not an IP address function checkValidEmailAddress(emailAddress){ var emailRE = /^[A-Za-z0-9_\-\.]+@(([A-Za-z0-9\-])+\.)+([A-Za-z\-])+$/; //return (emailAddress.match(emailRE) == true); //change for jslint return (emailAddress.match(emailRE) !== null); } //http://blog.stevenlevithan.com/archives/faster-trim-javascript //trim12 function trimWhitespace(str){ if(!str.replace){ return null; } str = str.replace(/^\s\s*/, ''); var ws = /\s/, i = str.length; while(ws.test(str.charAt(--i))){} //there is nothing within the braces. this is not a typo return str.slice(0, i + 1); } /***************************************************************/ function getBrowserGeometry(objBrowserWindow){ if(!objBrowserWindow){ objBrowserWindow = window; } //these won't necessarily contain valid references, but it //will prevent a bunch of scope chain lookups further in. var elDocElement = objBrowserWindow.document.documentElement; var elDocBody = objBrowserWindow.document.body; var windowSizeWidth = 0; var windowSizeHeight = 0; var horizontalScroll = 0; var verticalScroll = 0; var documentWidth = 0; var documentHeight = 0; if( typeof( objBrowserWindow.innerWidth ) == 'number' ){ //Non-IE windowSizeWidth = objBrowserWindow.innerWidth; windowSizeHeight = objBrowserWindow.innerHeight; horizontalScroll = objBrowserWindow.pageXOffset; verticalScroll = objBrowserWindow.pageYOffset; } else if( elDocElement && ( elDocElement.clientWidth || elDocElement.clientHeight ) ){ //IE 6+ in 'standards compliant mode' windowSizeWidth = elDocElement.clientWidth; windowSizeHeight = elDocElement.clientHeight; horizontalScroll = elDocElement.scrollLeft; verticalScroll = elDocElement.scrollTop; } else if( elDocBody && ( elDocBody.clientWidth || elDocBody.clientHeight ) ){ //IE 4 compatible windowSizeWidth = elDocBody.clientWidth; windowSizeHeight = elDocBody.clientHeight; horizontalScroll = elDocBody.scrollLeft; verticalScroll = elDocBody.scrollTop; } if( objBrowserWindow.innerHeight && objBrowserWindow.scrollMaxY ) // Firefox { documentWidth = objBrowserWindow.innerWidth + objBrowserWindow.scrollMaxX; documentHeight = objBrowserWindow.innerHeight + objBrowserWindow.scrollMaxY; } else if( elDocBody && elDocBody.scrollHeight > elDocBody.offsetHeight ) // all but Explorer Mac { documentWidth = elDocBody.scrollWidth; documentHeight = elDocBody.scrollHeight; } else if( elDocBody )// works in Explorer 6 Strict, Mozilla (not FF) and Safari { documentWidth = elDocBody.offsetWidth + elDocBody.offsetLeft; documentHeight = elDocBody.offsetHeight + elDocBody.offsetTop; } windowSizeWidth = parseInt(windowSizeWidth, 10); windowSizeHeight = parseInt(windowSizeHeight, 10); horizontalScroll = parseInt(horizontalScroll, 10); verticalScroll = parseInt(verticalScroll, 10); documentWidth = parseInt(documentWidth, 10); documentHeight = parseInt(documentHeight, 10); if(isNaN(windowSizeWidth)) { windowSizeWidth = null; } if(isNaN(windowSizeHeight)) { windowSizeHeight = null; } if(isNaN(horizontalScroll)) { horizontalScroll = null; } if(isNaN(verticalScroll)) { verticalScroll = null; } if(isNaN(documentWidth)) { documentWidth = null; } if(isNaN(documentHeight)) { documentHeight = null; } //return an object return { "viewportWidth" : windowSizeWidth, "viewportHeight" : windowSizeHeight, "horizontalScroll": horizontalScroll, "verticalScroll" : verticalScroll, "documentWidth" : documentWidth, "documentHeight" : documentHeight }; } /***************************************************************/ function returnMaxZindex() { var allElems = document.getElementsByTagName ? document.getElementsByTagName("*") : document.all; // or test for that too var maxZIndex = 0; var i = allElems.length; var sNum, maxEl; while(i--){ //gh - 31-dec-2010. //sNum = Number(getEffectiveStyle(allElems[i], 'z-index')); //the "+" here is the unary plus operator which will do implicit type conversion to a number sNum = +(getEffectiveStyle(allElems[i], 'z-index')); if(!isNaN(sNum) && sNum > maxZIndex){ maxZIndex = sNum; //maxEl = allElems[i]; //if we wanted to return the element which corresponds to the maxZindex } } return maxZIndex; } /***************************************************************/ //detects what DOCTYPE this document uses. returns an object. //accessable properties are: //detectDoctype.xhtml - XHTML, HTML //detectDoctype.version - 1.1, 4.0 //detectDoctype.importance - Strict, Transitional function detectDoctype(){ var re=/\s+(X?HTML)\s+([\d\.]+)\s*([^\/]+)*\//gi; var result = false; if(typeof document.namespaces != "undefined"){ result = document.all[0].nodeType==8 ? re.test(document.all[0].nodeValue) : false; } else{ result = document.doctype !== null ? re.test(document.doctype.publicId) : false; } if(result){ return {'xhtml': RegExp.$1.toUpperCase(), 'version': RegExp.$2.toUpperCase(), 'importance': RegExp.$3.toUpperCase()}; } return null; } //browser detection class //accessable properties are: //BrowserDetect.browser - Explorer, Mozilla, Chrome, etc. //BrowserDetect.version - 1, 2, 3, 4, etc. //BrowserDetect.OS - Windows, Linux, Mac, iPhone, etc. function BrowserDetect(){ this.init = function () { this.browser = this.searchString(this.dataBrowser) || "An unknown browser"; this.version = this.searchVersion(navigator.userAgent) || this.searchVersion(navigator.appVersion) || "an unknown version"; this.OS = this.searchString(this.dataOS) || "an unknown OS"; }; this.searchString = function (data){ for(var i=0, l=data.length;i) "enterkeypress":{ "attachToEvent": "keypress", "fn": function(objEvent){ // if(ddp.f.getEventKey(objEvent) == 13){ //clone the browser generated event object (this preserves mouse coordinates, originating time, etc..) var obj = cloneObject(objEvent, true); obj.bubbles = false; //fire the enterkey event manually (using the cloned event object as a parameter) //Also, the 5th argument tells the function to update the event parameter object "obj" with the //returnValue and cancelBubble results from the fired event (so we can pass it on to the original event object) fireEvent(this, 'enterkeypress', obj, false, true); if(obj.returnValue === false){ preventEventDefault(objEvent); } if(obj.cancelBubble){ stopEventPropagation(objEvent); } return obj.returnValue; } } } }; /***************************************************************/ //allow for putting user specified emulated events into the emulated events object function addEmulatedEvent(eventToEmulate, attachToEvent, emulatorFunction){ if(!ddpEmulatedEvents[eventToEmulate]){ ddpEmulatedEvents[eventToEmulate] = { "attachToEvent": attachToEvent, "fn": emulatorFunction }; return true; } return false; } /***************************************************************/ function addEvent(elEventTarget, strEventType, fnEventListener, forceAddOTE){ var arResults, i, l; //if strEventType is a space delimited string of multiple event types, if(strEventType.indexOf && strEventType.indexOf(' ') > -1){ strEventType = strEventType.split(' '); //convert it to an array } //an array of event targets can be passed and each target element will have the event type handler added to it if(isArray(elEventTarget)){ arResults = []; l=elEventTarget.length; for(i=0; i -1){ strEventType = strEventType.split(' '); //convert it to an array } //an array of event targets can be passed and each target element will have the event type handler added to it if(isArray(elEventTarget)){ arResults = []; l=elEventTarget.length; for(i=0; i=0; i++){ if(arListeners[i] == fnEventListener){ //if the listener is in the array arListeners.splice(i,1); //splice the listener out return 2; //return true on success } } } return 0; } else{ //if all else fails, use the old school approach return AERM_removeListener(elEventTarget, strEventType, fnEventListener) ? 3 : 0; } } /***************************************************************/ function fireEvent(elEventTarget, strEventType, objEventProperties, blnManualBubble, modifyObjEventProperties){ var arResults, i, l; //if strEventType is a space delimited string of multiple event types, if(strEventType.indexOf && strEventType.indexOf(' ') > -1){ strEventType = strEventType.split(' '); //convert it to an array } //the default value is undefined var returnValue = undefined; //an array of event targets can be passed and each target element will have the event type handler added to it if(isArray(elEventTarget)){ arResults = []; l=elEventTarget.length; for(i=0; i 1){ var i = getRegExpCacheIndex(reName); if(i 100){ delete regExpCache.itemsByName[regExpCache.shift()]; } regExpCache.push(reName); return (regExpCache.itemsByName[reName] = objRE); } function getRegExpCacheIndex(reName){ var i = regExpCache.length; while(--i){ if(regExpCache[i] == reName) return i; } return null; } /***************************************************************/ //hasClass //accepts a reference to an element and string containing the class name to search for. //returns true if the element has the specified class name, otherwise returns false. function hasClass(el, strClassToCheckFor){ //if(el && el.className){ var strClass = _getCSSClass(el); if(el && strClass){ //strClassToCheckFor = ddp.f.trimWhitespace(strClassToCheckFor); var re = getRegExp('hasClass_re1_' + strClassToCheckFor); if(!re) re = addRegExp('hasClass_re1' + strClassToCheckFor, new RegExp('\\b' + strClassToCheckFor + '\\b', 'gi')); //return re.test(el.className); return re.test(strClass); } return false; } /***************************************************************/ //setClass //sets an objects class (css) since IE and the Others work differently function setClass(el,theClass) { this.browserdt = new ddp.f.BrowserDetect(); if(this.browserdt.browser == 'Explorer' && this.browserdt.version < 8) el.setAttribute('className', theClass); else el.setAttribute('class', theClass); } /***************************************************************/ //setAlternatingClasses //gets elements by tag name (defaults to TR) and assigns the class names provided in arClasses in sequence //mostly usefull for coloring columns or rows of a table //e.g setAlternatingClasses(ddp.f.$('theTable'), ['rowRed','rowGreen','rowBlue']); //will result in a table with rows that are red, green, blue, red, green, blue, and repeat for all rows of the table function setAlternatingClasses(parentElementOrArray, arClasses, strTagName){ if(!parentElementOrArray) parentElementOrArray = document; if(ddp.f.isString(arClasses)) arClasses = ['', arClasses]; if(!strTagName) strTagName = 'tr'; //if it's an array, just assign it directly, if it's a DOMElement, get it's TR elements (or other specified tagName var arRows = ddp.f.isArray(parentElementOrArray) ? parentElementOrArray : parentElementOrArray.getElementsByTagName(strTagName); //iterate through the elements of the array and assign classnames from the arClasses array for(var i=0, il=arRows.length; i element or //there are no more nodes (in which case null is returned) function getElementForm(elElement, blnBridgeIframes){ if(typeof elElement != 'object' || elElement === null) throw 'ddp.f.getElementForm - elElement is not a DOM element.'; return climbDOMTree(elElement, function(){ if(this.nodeName.toLowerCase() == 'form') return this; }, null, blnBridgeIframes); } /***************************************************************/ //getRadioValueByName //returns the value of a radio group when supplied with the name //if no options in the rradio group have been selected, returns null. function getRadioValueByName(strRadioName){ var elRadioGroup = document.getElementsByName(strRadioName); for(var i=0, l=elRadioGroup.length; ied style sheet function addLinkStyleSheet(strCSSFile, elDocument, blnInsertFirst){ if(typeof elDocument != 'object') elDocument = window.document; blnInsertFirst = (blnInsertFirst === false) ? false : true; //check to see if the style has already been added. var elLinks = elDocument.getElementsByTagName('LINK'); for(var i=0, l=elLinks.length; i -1) return false; var objLinkedCSS = elDocument.createElement('LINK'); var elHead = elDocument.getElementsByTagName('head')[0]; objLinkedCSS.type='text/css'; objLinkedCSS.rel='stylesheet'; objLinkedCSS.media='screen'; objLinkedCSS.href=strCSSFile; if(blnInsertFirst && elHead.firstChild) elHead.insertBefore(objLinkedCSS, elHead.firstChild); else elHead.appendChild(objLinkedCSS); return true; } /***************************************************************/ //addScriptToHeader //adds a script tag to the document header //objProperties is an object with properties which are identical to //the attributes in the script tag you want to create eg. var objProperties = {type:'text/javascript',language:'javascript'} //elDocument is optional function addScriptToHeader(objProperties, strScriptText, elDocument){ if(typeof elDocument != 'object') elDocument = window.document; var elHead = elDocument.getElementsByTagName('head')[0]; var elScript = elDocument.createElement('script'); if(typeof objProperties == 'object'){ for(var key in objProperties){ if(objProperties.hasOwnProperty && objProperties.hasOwnProperty(key)){ try{ elScript.setAttribute(key, objProperties[key]); } catch(e){} } } } elScript.setAttribute('defer', 'defer'); if(elScript.canHaveChildren || elScript.canHaveChildren == null) elScript.appendChild(document.createTextNode(strScriptText)); else elScript.text = strScriptText; elHead.appendChild(elScript); } /***************************************************************/ //removeElement //Removes an element from the DOM function removeElement(refOrId, keepData){ //if an id string was passed, make sure we turn it into a reference var el = (ddp.f.isString(refOrId)) ? document.getElementById(refOrId) : refOrId; if(!keepData && el.nodeType === 1){ //remove the cached data for all child elements cleanElementData(el.getElementsByTagName("*")); //and the element to be removed cleanElementData([el]); } if(el.parentNode){ el.parentNode.removeChild(el); } } function replaceElement(elOld, elNew){ if(elOld.parentNode){ elOld.parentNode.replaceChild(elNew); } cleanElementData(elOld); } function detachElement(el){ removeElement(el, true); } function cleanElementData(arEls){ var i = arEls.length; while(i--){ _memorize.elData[arEls[i].__ddpGUID__] = undef; delete _memorize.elData[arEls[i].__ddpGUID__]; arEls[i].__ddpGUID__ = undef; //try{ delete arEls[i].__ddpGUID__; } //catch(e){ arEls[i].__ddpGUID__ = undef; } } } function getData(el, key){ var uid = el.__ddpGUID__; return (uid) ? (key ? _memorize.elData[uid][key] : _memorize.elData[uid]) : undef; } function setData(el, key, data, overwrite){ var uid = el.__ddpGUID__; if(!uid){ uid = el.__ddpGUID__ = GUID(); _memorize.elData[uid] = {}; } if(!overwrite && isObject(data) && isObject(_memorize.elData[uid][key])){ console.log(isObject(_memorize.elData[uid][key])); var obj = _memorize.elData[uid][key]; forOwnIn(data, function(val, ownKey){ obj[ownKey] = val; }); } else{ _memorize.elData[uid][key] = data; } } function removeData(el, key){ var uid = el.__ddpGUID__; if(!uid){ return; } if(_memorize.elData[uid] && _memorize.elData[uid].hasOwnProperty(key)){ _memorize.elData[uid][key] = undef; //for implementations that won't actually delete the property delete _memorize.elData[uid][key]; } } function setHTML(el, html){ //we do this to clean the data from the child elements we will be overwriting with the html cleanElementData(el.getElementsByTagName('*')); el.innerHTML = html; } function forOwnIn(obj, fn){ for(var key in obj){ if(obj.hasOwnProperty && obj.hasOwnProperty(key)){ fn(obj.hasOwnProperty(key), key, obj); } } } /***************************************************************/ //insertElementAfter //inserts an element into the DOM tree after the supplied element. // function insertElementAfter(elementToInsert, elementToInsertAfter){ elementToInsertAfter.parentNode.insertBefore(elementToInsert, elementToInsertAfter.nextSibling); } function removeChildren(el){ while(el.lastChild){ removeElement(el.lastChild); } } function replaceChildren(el, elNewChild){ removeChildren(el); el.appendChild(elNewChild); } /*---------------------------------------------------------------------*/ //arrayOfObjectsToTable // function arrayOfObjectsToTable(arObj, arFormatting, arAlternatingRowClasses, strHighlightedRowClass){ var elTable = document.createElement('table'); var elHeaderRow = arrayOfObjectsToHeaderRow(arObj, arFormatting); if(elHeaderRow){ var elTHead = document.createElement('thead'); elTHead.appendChild(elHeaderRow); elTable.appendChild(elTHead); } var elTBody = document.createElement('tbody'); var elFrag = arrayOfObjectsToTableRows(arObj, arFormatting, arAlternatingRowClasses, strHighlightedRowClass); elTBody.appendChild(elFrag); elTable.appendChild(elTBody); return elTable; } /*---------------------------------------------------------------------*/ //arrayOfObjectsToHeaderRow // function arrayOfObjectsToHeaderRow(arObj, arFormatting){ var elTR, elTH, str; elTR = document.createElement('TR'); var arToIterate = arFormatting; if(!arToIterate){ arToIterate = []; for(var key in arObj[0]){ if(arObj[0].hasOwnProperty(key)){ arToIterate.push({"title": key}); } } } if(arToIterate.length){ for(var i=0, l=arToIterate.length; i 0){ resultStr = strText.substr(0,1).toUpperCase(); for(x=1; x\\/\?]/gi; break; } if(reDataType){ if(!isString(strOrEl) && typeof strOrEl == 'object'){ strReturn = strOrEl.value.replace(reDataType, ''); strOrEl.value = strReturn; } else strReturn = strOrEl.replace(reDataType, ''); } return strReturn; } /***************************************************************/ //inputFilter //define characters allowed in fields with specific data types //USE WITH ONKEYPRESS EVENT ONLY function inputFilter(strDataType, objEvent) { //allow any non-character keys, backspace etc.. var charCode = document.all ? objEvent.keyCode : objEvent.which; if(charCode==8 || charCode==9 || charCode==0) return true; //see if the character is removed var strResult = removeInvalidChars(strDataType, String.fromCharCode(charCode)); if(strResult && strResult.length == 1) return true; cancelEvent(objEvent); //cancel the keypress return false; } /***************************************************************/ //formatPhoneNumber //Formats a phone number field into "(xxx) xxx-xxxx" or "xxx-xxxx" format, depending on length. function formatPhoneNumber(strOrEl){ //get the actual string we'll be working with var strValue = isString(strOrEl) ? strOrEl : strOrEl.value; //remove any non-numeric characters strValue = removeInvalidChars('phoneNumber', strValue); //if it's a ten digit number with a 1 at the beginning, assume it's a long distance indicator and remove it if(strValue.length == 11 && strValue.substr(0,1) == '1') strValue = strValue.substr(1); if(strValue.length == 7) //format a 7 digit number: 555-5555 strValue = strValue.substr(0,3) + '-' + strValue.substr(3); else if(strValue.length == 10) //format a 10 digit number: (555) 555-5555 strValue = '(' + strValue.substr(0,3) + ') ' + strValue.substr(3,3) + '-' + strValue.substr(6); //if we got passed an element and the new value is different, set the element's value if(!isString(strOrEl) && typeof strOrEl == 'object' && strOrEl.value != strValue) strOrEl.value = strValue; //return the resultant string return strValue; } /***************************************************************/ //imposeMaxLength //reproduces the effect "maxlength" has on a regular text for a

element 
function imposeMaxLength(intMaxLength, objEvent) {
  //get the object that fired the event
  var elText = getEventTarget(objEvent);
  var intTextLength = elText.value.length;
    
  if(objEvent.type=='keypress'){
    var chrCode = document.all ? objEvent.keyCode : objEvent.which;
    if(chrCode==8 || chrCode==9 || chrCode==0)
      return true;
    if(intTextLength >= intMaxLength){
      cancelEvent(objEvent);
      return false;
    }
  }
  else if(objEvent.type=='blur'){
    if(intTextLength > intMaxLength){
      elText.value = elText.value.substr(0, intMaxLength); //truncate the text
      alert('This field can contain a maximum of ' + intMaxLength + ' characters. The text has been truncated to fit.');
      cancelEvent(objEvent); //don't let the event happen
      if(typeof elText.focus == 'function')
        elText.focus(); //focus the element that just had it's text truncated
      return false;
    }
  }

return true;
}

/***************************************************************/
//getFromURL
//gets the value of a variable passed to the page in the querystring 
//[equivalent to VB's request.querystring(varName) ]
//optional second parameter is the string you want to search. (defaults to window.loacation.href otherwise)
function getFromURL(varName, strURL, allowNull){
  //use the url string passed or get the URL of this page
  if(!strURL)
    strURL = window.location.href;
    
  //if the URL contains a question mark, then it was loaded with arguments in the URL
  if(strURL.indexOf('?') != -1){
    //grab everything in the URL after the question mark
    var args = strURL.substr(strURL.indexOf('?')+1);
    //split the querystring into an array of strings with each element containing "example=blah"
    var splitArgs = args.split('&');
    //go through all the elements in the array of arguments
    for(var i=0, l=splitArgs.length; i<l; i++){
      //split each array element into an array of 2 strings with the first element containing "example" and the second "blah"
      splitArgs[i] = splitArgs[i].split('=');
      //if the variable passed in the querystring is our requested name
      if(splitArgs[i][0].toLowerCase()==varName.toLowerCase()){
        return decodeURIComponent(splitArgs[i][1]); //get it's contents
      }
    }
  }
     
  //if the variable doesn't exist return a null;
  return (allowNull) ? null : '';
}

/***************************************************************/
//extractServerandPath
//takes a URL and extracts the server and path
//removes any file name or arguments. 
function extractServerandPath(inVar){
  var returnStr = '' + inVar; //make sure a string
  
  if(returnStr.indexOf('?') != -1)
    returnStr = returnStr.substr(0,returnStr.indexOf('?'));
  returnStr = returnStr.substr(0,returnStr.lastIndexOf('/') + 1);
  
  return returnStr;
}

/***************************************************************/
//getServerNameFromURL
//
//
function getServerNameFromURL(strURL){
  var strServer = '' + strURL;
  
  if(strServer.indexOf('//') != -1){
    strServer = strServer.substr(strServer.indexOf('//') + 2);
    strServer = strServer.substr(0, strServer.indexOf('/'));
    
    return strServer.toLowerCase();
  }
  
  return null;
}

/***************************************************************/
//setCookie
//sets a browser cookie
//
function setCookie(name, value, expires, path, domain, secure) {
  document.cookie= name + "=" + escape(value) +
    ((expires) ? "; expires=" + expires.toGMTString() : "") +
    ((path) ? "; path=" + path : "") +
    ((domain) ? "; domain=" + domain : "") +
    ((secure) ? "; secure" : "");
}

/***************************************************************/
//getCookie
//gets the value of a browser cookie by the cookie's name 
//
function getCookie(name){
  var dc = document.cookie;
  var prefix = name + "=";
  var begin = dc.indexOf("; " + prefix);
  
  if(begin == -1){
    begin = dc.indexOf(prefix);
    if(begin != 0)
      return null;
  }
  else
    begin += 2;

var end = document.cookie.indexOf(";", begin);
  
  if(end == -1){
    end = dc.length;
  }
  
  return decodeURIComponent(dc.substring(begin + prefix.length, end));
}

/***************************************************************/
//deleteCookie
//removes a browser cookie from the browser cache
//
function deleteCookie(name, path, domain){
  if(getCookie(name)) {
    document.cookie = name + "=" +
      ((path) ? "; path=" + path : "") +
      ((domain) ? "; domain=" + domain : "") +
      "; expires=Thu, 01-Jan-70 00:00:01 GMT";
  }
}

/***************************************************************/
//getRandomInRange
//returns a random integer between intMinimum and intMaximum 
function getRandomInRange(intMinimum, intMaximum){
  //return Math.round(intMinimum + (Math.random() * (intMaximum - intMinimum)));
  return Math.floor((intMaximum - (intMinimum-1)) * Math.random()) + intMinimum;
}

/***************************************************************/
//isValidDate
//accepts either an element with a value attribute (like <input>) or a string 
//returns true if the date is valid and in "mm/dd/yy" (6/26/81) or "dd-mmm-yy" (26-jun-81) format
function isValidDate(elOrStr){
  try{
    if(parseDateString((typeof elOrStr == 'object') ? elOrStr.value : elOrStr) !== null)
      return true;
  }
  catch(e){}
  
  return false;
}

/***************************************************************/
//parseDateString 
//parses a date string and returns a js date object
function parseDateString(strValue) {
  var strDate = strValue;
  var objReturnDate;
  var dayPart = '';
  var monthPart = '';
  var yearPart = '';
  
  if(!strDate || !strDate.length){
    return null;
  }
    
  objReturnDate = (new Date());
  
  strDate = strDate.replace(/\//g, '-');
  strDate = strDate.replace(/ /g, '-');
  strDate = strDate.replace(/,/g, '-');
  strDate = strDate.replace(/\./g, '-');
  
  var temp = strDate.split('-');
  var parts = [];
  
  for(var x=0; x<temp.length; x++){
    if(temp[x] !== ''){ //changed from "!=" to "!==" - gh - 31-dec-2010
      parts[parts.length] = temp[x];
    }
  }

if(parts.length!=3){
    return null;
  }
  
  if(isMonth(parts[0])){
    dayPart = parts[1];
    monthPart = isMonth(parts[0]);
  }  
  else if(isMonth(parts[1])){
    dayPart = parts[0];
    monthPart = isMonth(parts[1]);
  }
  else{
    monthPart = parts[0];
    dayPart = parts[1];
  }

yearPart = fourDigitYear(parts[2]);

if(dayPart <= daysInMonth(yearPart, monthPart) && dayPart > 0 && monthPart < 13 && monthPart > 0 && yearPart > 1900 && yearPart < 2099){
    objReturnDate.setFullYear(yearPart,monthPart-1,dayPart);
    return objReturnDate;
  }
  else{
    return null;
  }
}

/***************************************************************/
//isMonth
//returns the month number from a month name (or short form)
//if the string doesn't contain a month name, returns zero 
function isMonth(inStr){
  if(!isString(inStr))
    return 0;
  inStr = inStr.toLowerCase();
  var monthName = ddp.l.monthName;
  var monthNameShort = ddp.l.monthNameShort;

for(var key in monthName){
    if(monthName.hasOwnProperty && monthName.hasOwnProperty(key)){
      for(var i=0, l=monthName[key].length; i<l; i++){
        if(inStr==monthName[key][i].toLowerCase() || (monthNameShort[key] && inStr==monthNameShort[key][i].toLowerCase()))
          return i+1;
      }
    }
  }
  
  return 0;
}

/***************************************************************/
//dateFormat
//formats a date in a specified type.
// 1 - dd-mmm-yyyy (26-Jun-1981)
// 2 - mm/dd/yyyy (6/26/1981)
function dateFormat(month, day, year, type, language){
  var objDate = null;
  if(!type)
    type = 1;

if(isString(language))
    language = language.substring(0,3).toLowerCase();
  else
    language = 'en';
  var monthName = ddp.l.monthName[language];
  var monthNameShort = ddp.l.monthNameShort[language];

if(typeof month == 'object')
    objDate = month;
  else if(typeof month == 'string' && !day && !year){
     objDate = parseDateString(month);
  }
  else if(month && day && year){
    objDate = new Date(year, month-1, day);
  }
  
  if(objDate){
    month = objDate.getMonth() + 1;
    day = objDate.getDate();
    year = objDate.getFullYear();
    var hour = objDate.getHours();
    var pm = false;
    var minute = objDate.getMinutes();
    var second = objDate.getSeconds();
    
    if(hour === 0)
      hour = 12;
    if(hour > 12){
      hour = hour - 12;
      pm = true;
    }
    
    if(minute<10)
      minute = '0' + minute;
    
    if(second<10)
      second = '0' + second;
    
    if(type==1)
      return day + '-' + monthNameShort[month-1] + '-' + year;
    else if(type==2) //used to be french. must stop from using in future
      return day + '-' + ddp.l.monthNameShort.fr[month-1] + '-' + year;
    else if(type==3)
      return month + '/' + day + '/' + year;
    else if(type==4)
      return year + '-' + month + '-' + day;
    else if(type==5)
      if(hour == 12 && minute == '00' && pm === false)
        return day + '-' + monthName[month-1].substr(0,3) + '-' + year;
      else
        return day + '-' + monthName[month-1].substr(0,3) + '-' + year + ' ' + hour + ':' + minute + (pm ? 'pm' : 'am');
  }
  
  return '';
}

function fourDigitYear(year){
  //implicit conversion to string
  year = '' + year;
  if(year.length == 2){
    return (parseInt(year, 10) < 50) ? '20' + year : '19' + year;
  }
  return (year.length == 4) ? year : -1;
}

function daysInMonth(year, month) {
  //return [31,((!(year % 4 ) && ( (year % 100 ) || !( year % 400 ) ))?29:28),31,30,31,30,31,31,30,31,30,31][month-1];
  return [31,((year % 4 === 0 && (year % 100 || year % 400 === 0) ) ? 29 : 28),31,30,31,30,31,31,30,31,30,31][month-1];
  //return [31,((!(year%4)&&((year%100)||!(year%400)))?29:28),31,30,31,30,31,31,30,31,30,31][month-1];
}

/**************************************************/
//Add or Strip Slashes to/from a String
/**************************************************/

function addSlashes(str){
  str=str.replace(/\\/g,'\\\\');
  str=str.replace(/\'/g,'\\\'');
  str=str.replace(/\"/g,'\\"');
  str=str.replace(/\0/g,'\\0');
  return str;
}

function stripSlashes(str){
  str=str.replace(/\\'/g,'\'');
  str=str.replace(/\\"/g,'"');
  str=str.replace(/\\0/g,'\0');
  str=str.replace(/\\\\/g,'\\');
  return str;
}

/**************************************************/

function linkTextToUrl(str) 
{
  //convert any text that contains http into a link
  var exp = /(\b(https?|ftp|file):\/\/[-A-Z0-9+&@#\/%?=~_|!:,.;]*[-A-Z0-9+&@#\/%=~_|])/ig;
  return str.replace(exp,"<a href='$1' target='_blank'>$1</a>");
}

/**************************************************/

function getNodeTree(object)
{  
  var sel = this.getSelection(object);
  var range = this.getRange(sel);  
  
  // get element of range
  var tag = this.getTag(range);
  
  if(tag === null) { return; }
  // get parent of element
  var node = this.getParent(tag);
  
  // init the tree as array with the current selected element
  var nodeTree = [tag];
  // get all parent nodes
  var ii = 1;
  
  while(node != null && node.nodeName != "#document") {
    nodeTree[ii] = node;
    node = this.getParent(node);      
    ii++;
  }
  
  return nodeTree;
}
  
function getSelection(object)
{
  var ifrm = object.contentWindow;
  
  var doc = ifrm.document;
  var sel = null;
  if(ifrm.getSelection){
    sel = ifrm.getSelection();
  }
  else if (doc.getSelection) {
    sel = doc.getSelection();
  }
  else if (doc.selection) {
    sel = doc.selection;
  }
  return sel;
}

function getRange(sel)
{
  return sel.createRange ? sel.createRange() : sel.getRangeAt(0);
}

function getTag(range)
{
    try {
        if(!ddp.f.isIE()) {
        var node = range.startContainer;  
        var pos = range.startOffset;
        if(node.nodeType != 3) { node = node.childNodes[pos]; }
        
        if(node.nodeName && node.nodeName.search(/#/) != -1) {
          return node.parentNode;
        }
        return node;
      }
      else {
        if(range.length > 0) {
          return range.item(0);
        }
        else if(range.parentElement()) {
          return range.parentElement();
        }
      }
      return null;
    }
    catch(e) {
      return null;
    }
}

function getParent(element) {
  if(element.parentNode) {
    return element.parentNode;
  }
  return null;
}

/**************************************************/

function setFloat(obj,where)
{
  var floatValue = obj.style['cssFloat'] || obj.style['styleFloat'];
  obj.style['cssFloat'] = where;
  obj.style['styleFloat'] = where;
}

/**************************************************/
//GUID
//generate a global unique identifier (all numeric)
function GUID(){
  //return (new Date()).getTime() + (Math.random() + '').replace('.', '') + _memorize.guidCounter++;
  return (new Date()).getTime() + _memorize.guidCounter++;
}

/**************************************************/
//Run the active part of the library core
/**************************************************/
  //set the default one time events
  //(when addEvent tries to add more handlers after they've fired once, the "added" handler is executed immediately)
  setOneTimeEvent(window, 'load');
  setOneTimeEvent(document, 'ready');
  
  
  var elTest; //the element we'll be trying to add as a test of document readiness 
  var docReadyInterval; //the interval id we'll use to cancel the check interval later
  docReadyInterval = window.setInterval(function(){
    if(document){
      var elBody = document.getElementsByTagName('body')[0];
      if(typeof elBody != 'undefined'){
        if(!elTest){
          elTest = document.createElement('input');
          elTest.type = 'hidden';
          elTest.style.display = 'none';
        }
        try{
          elBody.appendChild(elTest);
          ddp.f.removeElement(elTest);
          
          //if there was no error thrown, then we can manipulate the DOM
          window.clearInterval(docReadyInterval);
          docReadyInterval = null;
          ddp.f.documentReadyTime = (new Date().getTime());
          fireEvent(document, 'ready', {"cancelable":false});
        }
        catch(e){}
      }
    }
  }, 25);
    
  
/**************************************************/

/**************************************************/
//Export the public functions to a public namespace
//use: ddp.f.function();
/**************************************************/
  
  //shorten the reference to the ddp namespace we want to add to (and avoid scope lookups)
  var n = ddp.f;
  
  n.memorize  = _memorize;
  
  n.nodeTypes = nodeTypes;
  n.$ = $;
  n.$c = $c;
  n.addLoadEvent = addLoadEvent;
  n.addModule = addModule;
  n.obsEvent = obsEvent;
  n.mousePosition = mousePosition;
  n.makeRealArray = makeRealArray;
  n.randomSortArray = randomSortArray;
  n.isArray = isArray;
  n.isString = isString;
  n.isObject = isObject;
  n.isFunction = isFunction;
  n.isDate = isDate;
  n.cloneObject = cloneObject;
  n.arrayCompare = arrayCompare;
  n.removeAlpha = removeAlpha;
  n.removeNonAsciiWord = removeNonAsciiWord;
  n.checkValidPhoneNumber = checkValidPhoneNumber;
  n.checkValidEmailAddress = checkValidEmailAddress;
  n.trimWhitespace = trimWhitespace;
  n.isIE = isIE;
  n.getBrowserGeometry = getBrowserGeometry;
  n.returnMaxZindex = returnMaxZindex;
  n.setOneTimeEvent = setOneTimeEvent;
  n.addEvent = addEvent;
  n.removeEvent = removeEvent;
  n.fireEvent = fireEvent;
  n.isEventSupported = isEventSupported;
  n.stopEventPropagation = stopEventPropagation;
  n.preventEventDefault = preventEventDefault;
  n.cancelEvent = cancelEvent;
  n.getEventTarget = getEventTarget;
  n.getEventKey = getEventKey;
  n.detectDoctype = detectDoctype;
  n.addClass = addClass;
  n.removeClass = removeClass;
  n.hasClass = hasClass;
  n.setClass = setClass;
  n.setAlternatingClasses = setAlternatingClasses;
  n.getRegExp = getRegExp;
  n.addRegExp = addRegExp;
  n.getEffectiveStyle = getEffectiveStyle;
  n.BrowserDetect = BrowserDetect;
  n.getAncestorByClassName = getAncestorByClassName;
  n.getElementsByClassName = getElementsByClassName;
  n.getChildElementById = getChildElementById;
  n.isChild = isChild;
  n.climbDOMTree = climbDOMTree;
  n.getElementForm = getElementForm;
  n.getRadioValueByName = getRadioValueByName;
  n.getElementPosition = getElementPosition;
  n.getElementLeft = getElementLeft;
  n.getElementWidth = getElementWidth;
  n.getElementRight = getElementRight;
  n.getElementTop = getElementTop;
  n.getElementHeight = getElementHeight;
  n.getElementBottom = getElementBottom;
  n.addStyleSheet = addStyleSheet;
  n.addLinkStyleSheet = addLinkStyleSheet;
  n.addScriptToHeader = addScriptToHeader;
  n.removeElement = removeElement;
  n.detachElement = detachElement;
  n.getData = getData;
  n.setData = setData;
  n.removeData = removeData;
  n.setHTML = setHTML;
  n.forOwnIn = forOwnIn;
  n.insertElementAfter = insertElementAfter;
  n.removeChildren = removeChildren;
  n.replaceChildren = replaceChildren;
  n.arrayOfObjectsToTable = arrayOfObjectsToTable;
  n.arrayOfObjectsToTableRows = arrayOfObjectsToTableRows;
  n.arrayOfObjectsToHeaderRow = arrayOfObjectsToHeaderRow;
  n.setOpacity = setOpacity;
  n.toCamelCase = toCamelCase;
  n.countOccurances = countOccurances;
  n.removeInvalidChars = removeInvalidChars;
  n.inputFilter = inputFilter;
  n.formatPhoneNumber = formatPhoneNumber;
  n.imposeMaxLength = imposeMaxLength;
  n.getFromURL = getFromURL;
  n.extractServerandPath = extractServerandPath;
  n.getServerNameFromURL = getServerNameFromURL;
  n.setCookie = setCookie;
  n.getCookie = getCookie;
  n.deleteCookie = deleteCookie;
  n.getRandomInRange = getRandomInRange;
  n.isValidDate = isValidDate;
  n.parseDateString = parseDateString;
  n.dateFormat = dateFormat;
  n.addSlashes = addSlashes;
  n.stripSlashes = stripSlashes;
  n.linkTextToUrl = linkTextToUrl;
  n.getNodeTree = getNodeTree;
  n.getSelection = getSelection;
  n.getRange = getRange;
  n.getTag = getTag;
  n.getParent = getParent;
  n.setFloat = setFloat;
  n.GUID = GUID;
})();

//language object
//strings are encoded with unicode \u0000 escaping to make sure they are interpreted properly
ddp.l = {
  "monthName":{
    "en":['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November','December'],
    "fr":['Janvier', 'F\u00e9vrier', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'A\u00f4ut','Septembre','Octobre','Novembre','D\u00e9cembre'],
    "es":['enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio', 'julio', 'agosto', 'septiembre', 'octubre', 'noviembre', 'diciembre']
  },
  "monthNameShort":{
    "en":['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov','Dec'],
    "fr":['Jan', 'F\u00e9v', 'Mars', 'Avr', 'Mai', 'Juin', 'Juil', 'A\u00f4ut','Sept','Oct','Nov','D\u00e9c'],
    "es":['ene', 'feb', 'mar', 'abr', 'may', 'jun', 'jul', 'ago', 'sep', 'oct', 'nov', 'dic']
  },
  "dayName":{
    "en":['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
    "fr":['Dimanche','Lundi','Mardi','Mercredi','Jeudi','Vendredi','Samedi'],
    "es":['Domingo','Lunes','Martes','Mi\u00e9rcoles','Jueves','Viernes','S\u00e1bado']
  },
  "ok":{"en":"OK", "fr":"OK", "es":"OK"}, //useless, I guess, other than to confirm the translation
  "save":{"en":"Save","fr":"Valider","es":""}, //incomplete
  "apply":{"en":"Apply","fr":"Appliquez","es":""}, //incomplete
  "submit":{"en":"Submit","fr":"Envoi","es":""}, //incomplete (es)
  "select":{"en":"Select","fr":"S\u00e9lectionner","es":""}, //incomplete
  "selectAll":{"en":"Select All","fr":"S\u00e9lectionner tout","es":""}, //incomplete
  "cancel":{"en":"Cancel","fr":"Annul\u00e9r","es":"Cancelar"},
  "cancelAll":{"en":"Cancel All","fr":"Annul\u00e9r tout","es":""}, //incomplete
  "clear":{"en":"Clear","fr":"D\u00e9gagez??","es":"ES_Clear"}, //incomplete ---------------------------------------------------
  "delete":{"en":"Delete","fr":"Supprimer","es":"Eliminar"},
  "back":{"en":"Back","fr":"Retournez","es":""}, //incomplete
  "close":{"en":"Close","fr":"Fermer","es":"ES_Close"}, //incomplete
  "download":{"en":"Download","fr":"T\u00e9l\u00e9charger","es":""}, //incomplete
  "print":{"en":"Print", "fr":"Imprimer", "es":"Tecla de impresi\u00f3n"},
  "loading":{"en":"Loading","fr":"Chargement","es":"Cargando"},
  "username":{"en":"Username","fr":"Identifiant","es":"Usuario"},
  "password":{"en":"Password","fr":"Mot passe","es":"Contrase\u00f1a"},
  "size":{"en":"Size","fr":"Taille","es":"Tama\u00f1o"},
  "type":{"en":"Type","fr":"Type","es":"Tipo"},
  "skip":{"en":"Skip","fr":"Ignor\u00e9","es":"Omitir"},
  "pause":{"en":"Pause","fr":"Suspendre","es":"Pausar"},
  "properties":{"en":"Properties","fr":"Propri\u00e9t\u00e9s","es":"Propiedades"},
  "remove":{"en":"Remove","fr":"Annuler","es":"Eliminar"},
  "start":{"en":"Start","fr":"D\u00e9marrer","es":"Iniciar"},
  "stop":{"en":"Stop","fr":"Arr\u00eater","es":"Detener"},
  "name":{"en":"Name","fr":"Nom","es":"Nombre"},
  "status":{"en":"Status","fr":"Statut","es":"Estado"},
  "today": {"en": "Today", "fr": "Aujourd'hui", "es": "Hoy"},
  "finished":{"en":"Finished","fr":"Termin\u00e9","es":"Finalizado"}
};