/*dependencies
    <dependencies/>
dependencies*/

/*------------------------------------------------------------
 COPYRIGHT!!
 CODE WRITTEN BY ANDREW GULBRONSON
 IF YOU HAPPEN TO HAVE BEEN DIGGING THROUGH ANY OF MY CODE AND COME ACROSS THIS
 JS FILE AND DECIDE YOU WANT TO USE IT GO AHEAD, BUT YOU MUST KEEP THIS
 NOTICE IN THE CODE.
--------------------------------------------------------------*/

var Debug = false;
/*THIS IS A 'STATIC' CLASS USED FOR VARIOUS COMMON FUNCTIONALITY.*/
function Shared() {}
// number of decimals, decimal separator, thousands separator.
Number.prototype.formatMoney = function(c, d, t, AddDollarSign){
var n = this, c = isNaN(c = Math.abs(c)) ? 2 : c, d = d == undefined ? "." : d, t = t == undefined ? "," : t, s = n < 0 ? "-" : "", i = parseInt(n = Math.abs(+n || 0).toFixed(c)) + "", j = (j = i.length) > 3 ? j % 3 : 0;
//var n = this, c = (c == null || isNaN(c = Math.abs(c)) ? 2 : c), d = (d == null || d == undefined ? "," : d), t = (t == null || t == undefined ? "." : t), s = n < 0 ? "-" : "", i = parseInt(n = Math.abs(+n || 0).toFixed(c)) + "", j = (j = i.length) > 3 ? j % 3 : 0;
	return (AddDollarSign ? "$" : "") + (s + (j ? i.substr(0, j) + t : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : "")).toString();
};

Number.prototype.FormatMoney = function(c, d, t, AddDollarSign) { return this.formatMoney(c, d, t, AddDollarSign); }


String.prototype.GlobalReplace = function(ToReplace, ReplaceWith) {
    return this.replace(new RegExp(ToReplace, "g"), ReplaceWith);
}

String.prototype.RemoveMoneyFormat = function() {

    return this.GlobalReplace(",", "").GlobalReplace("\\$", "");

}

String.prototype.Trim = function() {

    return Shared.Trim(this);

}

String.prototype.Contains = function (Text) {

    return (this.toLowerCase().indexOf(Text) > -1 ? true : false);

}

Shared.NullToEmptyString = function (value) {

    return (value == null || value == "null" ? "" : value);

}

String.prototype.IsNullOrEmpty = function() {

    var txt = Shared.NullToEmptyString(this).Trim();
    return (txt.length == 0);

}

Shared.CopyObject = function (obj) {

    var newObj = (obj instanceof (Array) ? [] : {});
    for (var i in obj) {
        if (obj[i] && typeof (obj[i]) == "object") {
            newObj[i] = Shared.CopyObject(obj[i]);
        } else { newObj[i] = obj[i]; }
    }

    return newObj;

}

Shared.RemovePhoneFormat = function(Phone) {

    return Phone.Trim().GlobalReplace(" ", "").GlobalReplace("-", "").GlobalReplace("\\.", "").GlobalReplace("\\,", "").GlobalReplace("\\(", "").GlobalReplace("\\)", "");

}
Shared.FormatPhoneNumber = function(Phone, Format) {

    if (!Phone.IsNullOrEmpty()) {
        var standard = "xxx-xxx-xxxx";
        if (Shared.StringIsNullOrEmpty(Format)) { Format = standard; }

        Phone = this.RemovePhoneFormat(Phone);

        var areaCode = Phone.substring(0, 3);
        var firstThree = Phone.substring(3, 6);
        var lastFour = Phone.substring(6, 10);

        if (Format == standard) { Phone = areaCode + "-" + firstThree + "-" + lastFour; }
        else if (Format == "(xxx) xxx-xxxx") { Phone = "(" + areaCode + ") " + firstThree + "-" + lastFour; }
    }
    return Phone;
}

/*BREAK*/
Shared.StringIsNullOrEmpty = function(sText) {
    if (sText == null) { return true; }
    sText = sText.toString().Trim();
    return (sText.length == 0);
    //return this.replace(/^\s+|\s+$/g, '');
}

Shared.StringContains = function(string, sText) {
    return string.Contains(sText);
}

Date.prototype.Format = function(FormatString) {

    var standard = "mm/dd/yyyy";
    FormatString = (Shared.StringIsNullOrEmpty(FormatString) ? standard : FormatString.toLowerCase()); //   default it if its null or empty, or set it to itself in lower case.

    if (FormatString == standard) { return ((parseInt(this.getMonth()) + 1) + "/" + this.getDate() + "/" + this.getFullYear()); }

}




/* WORKS IN MOST NEWER BROWSERS-GRACEFULLY DEGRADES
EXAMPLE IMPLEMENTATION 

Shared.AddClosingPrompt(SavedStatus, "Your data has not been saved. All changes will be lost!");
function SavedStatus() { return hasSaved; }

*/
Shared.AddClosingPrompt = function(DelegateSkipMessage, Message) {

    function ConfirmSave(e) {

        var skipMessage = DelegateSkipMessage();
        if (!skipMessage) {
            e.returnValue = Message;
        }

    }
    Shared.AttachEvent(window, "beforeunload", ConfirmSave);
}






Shared.GetPosition = function (element) {

    var coords = new Object();
    coords.x = Shared.GetOffset(element, false);
    coords.y = Shared.GetOffset(element, true);
    return coords;

}

Shared.RetrieveElement = function(object) {

    var element = null;
    if (typeof (object) == "string") { element = document.getElementById(object); }
    else if (typeof (object) == "object") { element = object; }
    return element;

}

Shared.ToggleGhostButton = function(BtnToShow, BtnToHide) {

    var btnShow = Shared.RetrieveElement(BtnToShow);
    var btnHide = Shared.RetrieveElement(BtnToHide);

    if (btnShow != null && btnHide != null) {

        btnShow.style.display = "inline";
        btnHide.style.display = "none";

    }

}

Shared.AddLoadEvent = function(delegate) {

    if (typeof (window.onload) != "function") {
        Shared.AttachEvent(window, "load", delegate);
    } else {
        var oldOnLoad = window.onload;
        Shared.AttachEvent(window, "load",
            function() {
                if (oldOnLoad) { oldOnLoad(); }
                delegate();
            }
        );
    }
}

// NOT TESTED YET!!!!
Shared.AddEvent = function(Event, Delegate) {

    var oldEvent = Event;
    Event = function () {

        if (oldEvent) { oldEvent(); }
        Delegate();

    }

}


Shared.Random = function (Small, Large) {

    var i = Math.floor(Math.random() * (Large - Small + 1)) + Small;
    if(i < Small) { i = Shared.Random(Small, Large); }
    return i;
}

Shared.CancelBubble = function (evt) {

    if(!evt) { evt = window.event; }
    evt.cancelBubble = true;

}

/*
Shared.UnEscapeXml = function(Xml) {

    Xml = Xml.GlobalReplace("&lgt;", "<").GlobalReplace("&hgt;", ">");
    return Xml;

}

Shared.EscapeXml = function (Xml) {

    Xml = Xml.GlobalReplace("<", "&lgt;").GlobalReplace(">", "&hgt;");
    return Xml;

}*/


Shared.SelectText = function (element, StartPosition, Length) // NOT THOROUGLY TESTED
{ 

    var html = element.innerHTML;
    var range = null;
    if (document.selection) 
    {
        range = document.body.createTextRange();

        range.moveToElementText(element);
        range.setEndPoint("EndToEnd", range);
        range.moveStart('character', StartPosition);
        
        if(Length + StartPosition > html.length) { Length = html.length - StartPosition; }
        
        range.moveEnd('character', -(html.length - StartPosition - Length));        
        
        range.select();
    } 
    else 
    { 
        window.getSelection().removeAllRanges();
        
        while ( element.hasChildNodes() ) { element = element.childNodes[0]; }
        
        var range = document.createRange();
        range.setStart(element, StartPosition);
        if (StartPosition + Length > element.length) {Length = element.length - StartPosition; }
        range.setEnd(element, StartPosition + Length);
        window.getSelection().addRange(div);
    }

}

Shared.RemoveSelection = function (element) { // NOT THOROUGLY TESTED

    if(document.selection) { Shared.SelectText(element, 0, 0); }
    else { window.getSelection().removeAllRanges(); }

}


Shared.MoveElementToCenterScreen = function (ElementToMove) {

    var yMid = (parseInt(Shared.BrowserHeight()) / 2);
    var xMid = (parseInt(Shared.BrowserWidth()) / 2);

    var width = parseInt(Shared.GetStyle(ElementToMove, "width"));
    var height =  parseInt(Shared.GetStyle(ElementToMove, "height"));
    
    if(isNaN(width)) { width = parseInt(Shared.GetOffset(ElementToMove, false)); }
    if(isNaN(height)) { height = parseInt(Shared.GetOffset(ElementToMove, true)); }
    
    if(isNaN(width) || isNaN(height)) { return; }

    ElementToMove.style.top = ((yMid - (height / 2)) + Shared.ScrollTop()).toString() + "px";
    ElementToMove.style.left = ((xMid - (width / 2)) + Shared.ScrollLeft()).toString() + "px";

}

/*

get event and element that triggered
function setMouseStatusTrue(e) {

    e = e || window.event;
    var theTarget = e.target || e.srcElement;
    if(theTarget && (theTarget.nodeType == 3 || theTarget.nodeType == 4)) { theTarget = theTarget.parentNode; }
}

*/

Shared.AddClass = function(obj, ClassName) {
    if (!obj.className.Contains(ClassName)) {
        obj.className += " " + ClassName;
    }
}

Shared.RemoveClass = function(obj, ClassName) {

    obj.className = obj.className.GlobalReplace(ClassName, "");
}

Shared.RemoveMoneyFormat = function (value) {

    return parseFloat(value.replace(/,/g, "").replace("$", "").replace("(", "").replace(")", ""));

}

Shared.ScrollToElement = function(obj) {

    if (obj != null) {
        window.scrollTo(Shared.GetOffset(obj, false), Shared.GetOffset(obj, true));
    }

}


//Shared.AddEvent = function(IDOrElement, evt, delegate) {

//    var obj = Shared.RetrieveElement(IDOrElement);
//    if (obj) {
//        evt = evt.toLowerCase();


//        if (evt == "blur" && typeof (obj.onblur) != "function") {
//            Shared.AttachEvent(obj, evt, delegate);
//        } else {

//            var oldEvent;
//            if (evt == "blur") {
//                oldEvent = obj.onblur;
//                Shared.AttachEvent(obj, evt,
//                    function() {
//                        if (oldEvent) { oldEvent(); }
//                        delegate();
//                    });
//            }

//        }
//    }
//}

Shared.AttachEvent = function(IDOrElement, evt, myFunction) {

    var obj = Shared.RetrieveElement(IDOrElement);
    if (obj) {
        evt = evt.toLowerCase();

        if (obj.addEventListener) {

            obj.addEventListener(evt, myFunction, false);
            return true;

        } else if (obj.attachEvent) {

            if (evt.indexOf("on") != 0) { evt = "on" + evt; }
            return obj.attachEvent(evt, myFunction);

        } /*else {
            obj.onmouseover = myFunction;
            obj.onmouseout = myFunction;
        }*/
    }

}

Shared.DetachEvent = function(IDOrElement, evt, myFunction) {

    var obj = Shared.RetrieveElement(IDOrElement);
    if (obj) {
        evt = evt.toLowerCase();

        if (obj.addEventListener) {

            obj.removeEventListener(evt, myFunction, false);
            return true;

        } else if (obj.attachEvent) {

            if (evt.indexOf("on") != 0) { evt = "on" + evt; }
            return obj.detachEvent(evt, myFunction);

        } /*else {
            obj.onmouseover = myFunction;
            obj.onmouseout = myFunction;
        }*/
    }

}

/*Fired when enter is pressed on an element*/
/*example implementation
<input type = "text" id = "txtSearch" class = "Search" onkeydown = "event.cancelBubble = true; Shared.ClickElement(event, 'btnSearch');" />
*/
Shared.ClickElement = function (event, target) {
    //var __nonMSDOMBrowser = (window.navigator.appName.toLowerCase().indexOf('explorer') == -1);

    if (event.keyCode == 13) {
        var src = event.srcElement || event.target;
        if (!src || (src.tagName.toLowerCase() != "textarea")) {
            /*var defaultButton;
            if (__nonMSDOMBrowser) {
               defaultButton = document.getElementById(target);
            }
            else {
                defaultButton = document.all[target];
            }*/
            var defaultButton = document.getElementById(target);
            if (defaultButton && typeof(defaultButton.click) != "undefined") {
                defaultButton.click();
                event.cancelBubble = true;
                if (event.stopPropagation) { event.stopPropagation(); }
                return false;
            }
        }
    }
    return true;
}

Shared.GetMouseCoordinates = function (e) {

    var x, y;
    
    if(typeof(e.pageX) == "number") {
    
        // most browsers
        x = e.pageX;
        y = e.pageY;
    
    } else if( typeof(e.clientX) == "number") {
    
        //IE and older browsers
        x = e.clientX;
        y = e.clientY;
        
        if( document.documentElement && ( document.documentElement.scrollLeft || document.documentElement.scrollTop ) ) {
            //IE 6 (in standards compliant mode)
            x += document.documentElement.scrollLeft;
            y += document.documentElement.scrollTop;
          }
    }
    var coords = new Object();
    coords.x = x;
    coords.y = y;
    return coords;
}

Shared.GetStyle = function(Element, CssProperty) {

    if (typeof (Element) == "string") { Element = el(Element); }
    try {
        if (Element.currentStyle) {
            var convertToCamelCase = CssProperty.replace(/\-(.)/g, function(m, l) { return l.toUpperCase() });
            return Element.currentStyle[convertToCamelCase];
        }
        else if (window.getComputedStyle) {
            var elementStyle = window.getComputedStyle(Element, "");
            return elementStyle.getPropertyValue(CssProperty);
        }
    } catch (x) { }
}

Shared.ImageRollover = function (img) {

    var sSrc = img.src;
    if (sSrc.indexOf("_2.jpg") > -1) { sSrc = sSrc.replace("_2.jpg", ".jpg"); }
    else { sSrc = sSrc.replace(".jpg", "_2.jpg"); }

    img.src = sSrc;
}

/*BREAK*/
/* returns an element with the given id*/
function el(sID) {

    return document.getElementById(sID);

}

Shared.FullPath = function () {

    var urlArray = window.location.href.toLowerCase().split("/");
    urlArray.pop();
    return urlArray.join("/") + "/";

}


Shared.CheckDialogArguments = function () {

    try {
    
        if(!dialogArguments) { return false; }
        
    } catch(x) { return false; }
    
    return true;

}

Shared.ArrayContains = function (array, value, CaseSensitive) {
        
    if (CaseSensitive == null) { CaseSensitive = false; }

    for(var i = 0; i < array.length; i++) {
    
        if(value == array[i] || ( !CaseSensitive && value.toLowerCase() == array[i].toLowerCase() )) { return true; }
    
    }
    
    return false;

}

/* MIGHT NOT WORK CORRECTLY YET!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
Shared.Round = function (dValue, iDecimals) {

    var isThreshold = (dValue > 8191 && dValue < 10485 ? true : false);
    
	if (isThreshold) { dValue -= 5000; }
	
	var newnumber = Math.round(((dValue * Math.pow(10,iDecimals))) / Math.pow(10,iDecimals));
	
	if(isThreshold) { newnumber -= 5000; }
	
	return newnumber;

}

/* INSERTS ELEMENT AFTER SPECIFIED ELEMENT */
Shared.InsertAfter = function (newElement, targetElement) {

    //target is what you want it to go after. Look for this element's parent.	
    var parent = targetElement.parentNode; 	
    
    //if the parents lastchild is the targetElement...	
    if(parent.lastchild == targetElement) {		
    
        //add the newElement after the target element.		
        parent.appendChild(newElement);
    } else {

		// else the target has siblings, insert the new element between the target and it's next sibling.
		parent.insertBefore(newElement, targetElement.nextSibling);
		
    }

}

/*BREAK*/
/* accepts an ID, sets that elements value*/
Shared.SetElementValue = function (sID, sValue) {

    var object = el(sID);
    
    if(sID.indexOf("chk") > -1) {
    
        var bChecked = (sValue.toLowerCase() == "true" || sValue == "1" ? true : false);
        object.checked = bChecked;
    
    } else if(sID.indexOf("txt") > -1 || sID.indexOf("drp") > -1) {
    
        object.value = sValue;

    }

}

// creates either the opening or closing tag of a node, escaped to safely be placed in a hidden field for submission.
Shared.MakeSafeNode = function (name, bIsClosing, arAttributeNames, arAttributeValues) {

    var sXml = "&lgt;" + (bIsClosing ? "/" : "") + name;
    
    if(!bIsClosing && arAttributeNames != null) {
    
        for(var i = 0; i < arAttributeNames.length; i++) {
        
            sXml += " " + arAttributeNames[i] + " = \"";
            
            if(arAttributeValues != null && i < arAttributeValues.length) { sXml += arAttributeValues[i]; }
            
            sXml += "\"";
        
        }
    
    }
    
    sXml += "&hgt;";
    return sXml;

}

// creates the entire xml node, escaped to safely be placed in a hidden field for submission. The InnerXml passed must already be escaped if it is actual xml and not text
Shared.BuildSafeNode = function(InnerXml, NodeName, AttributeNames, AttributeValues) {

    return Shared.MakeSafeNode(NodeName, false, AttributeNames, AttributeValues) + InnerXml + Shared.MakeSafeNode(NodeName, true, null, null);

}


/*BREAK*/
/* functionality to strip all leading, trailing, and double spaces*/
Shared.SpaceTrim = function(sToTrim) {

    if (sToTrim == null) { return ""; }
    if (sToTrim.indexOf(" ") > -1) {

        var sTrimConcat = "";
        var arTrimParts = sToTrim.split(" ");
        var iTrimLen = arTrimParts.length;

        for (var ii = 0; ii < iTrimLen; ii++) {

            if (arTrimParts[ii] != "") {

                if (sTrimConcat != "") { sTrimConcat += " "; }
                sTrimConcat += arTrimParts[ii];

            }

        }

        return sTrimConcat;

    } else {

        return sToTrim;

    }

}

Shared.Trim = function (sToTrim) { return Shared.SpaceTrim(sToTrim); }
/*BREAK*/
/* remove html markup from textbox, etc..
   obj:         the txtbox
   sAlias:      user friendly desc of txtbox
   AlertUser:   if markup removed should the user be notified.*/
Shared.StripMarkup = function (obj, sAlias, AlertUser) {

    var sVal = obj.value;
    
    if(sVal.indexOf("<") > -1 || sVal.indexOf(">") > -1) {
    
        sVal = sVal.replace(/</g, "").replace(/>/g, "");
	    obj.value = sVal;

	    if (AlertUser) {
	    
	        if(sAlias == null) { sAlias = obj.id; }
	        alert("The characters \"<\" and \">\" are not allowed\nin the " + sAlias + " field. They have been removed."); 
	        
	    }	
	}

}

Shared.InvalidXmlChars = new Array("&",     /*"#",*/        "<",    ">",    "\"",     "'");
Shared.ValidXmlChars   = new Array("&amp;", /*"&#00035;",*/ "&lt;", "&gt;", "&quot;", "&apos;");

Shared.EscapeXml = function(XmlString) {

    for (var i = 0; i < this.InvalidXmlChars.length; i++) {

        var g = this.ValidXmlChars[i];
        var b = this.InvalidXmlChars[i];

        XmlString.GlobalReplace(b, g);

    }

    return XmlString;

}

Shared.UnEscapeXml = function(XmlString) {

    for (var i = 0; i < this.InvalidXmlChars.length; i++) {

        var g = this.ValidXmlChars[i];
        var b = this.InvalidXmlChars[i];
        XmlString.GlobalReplace(g, b);

    }

    return XmlString;

}


/*BREAK*/
Shared.EscapeQuoteAndApos = function (sText) {

    return sText.replace(/ & /g, " and ").replace(/\"/g, "&quot;").replace(/\'/g, "&apos;");

}
/*BREAK*/
Shared.UnEscapeQuoteAndApos = function(sText) {

    //try {
    return sText.replace(/&quot;/g, "\"").replace(/&apos;/g, "'").GlobalReplace(" and ", " & ");
    //}catch(x){alert(?);}

}
/*BREAK*/
Shared.BoolToInt = function (bool) {

    if(bool.toLowerCase() == "true") { return 1; }
    else { return 0; }

}
/*BREAK*/
Shared.IntToBool = function (integer) {

    if(integer == 1) { return true; }
    else { return false; }

}

/*BREAK*/
/* counts down how many chars are left in suggestion box submission*/
Shared.CountDownChars = function (txtBoxID, objCountID, iLen) {

    var txtBox = document.getElementById(txtBoxID);
    var objCount = document.getElementById(objCountID);
    if(iLen == null || isNaN(iLen)) { iLen = 3000; }
    
    if(txtBox) {
    
        var iNum = parseInt(iLen - txtBox.value.length);
        if(iNum < 0) {
    	
	        iNum = 0;
	        txtBox.value = txtBox.value.substring(0, iLen);
    	
        }
        
    }
	
    try {
    
        objCount.innerHTML = iNum.toString() + " characters remaining.";
        
    } catch(x) {
    
        objCount.value = iNum.toString() + " characters remaining.";
    
    }

}
/*BREAK*/
/* sets and plays the IE filter on an object*/
Shared.SetFilter = function(theObj, sDisplay) {

    sDisplay = sDisplay.toLowerCase();
    //theObj.filters[0].Apply();
    theObj.filters["DXImageTransform.Microsoft.RandomDissolve"].Apply();
    theObj.style.display = sDisplay;
    //if (sDisplay != "none") { theObj.filters[0].Play(); }
    if (sDisplay != "none") { theObj.filters["DXImageTransform.Microsoft.RandomDissolve"].Play(); }

}

// same as above, but more versatile.
Shared.Set_Filter = function (theObj, sText) {

    theObj.style.display = "none";
    theObj.innerHTML = sText;
    theObj.filters["DXImageTransform.Microsoft.RandomDissolve"].Apply();
    theObj.style.display = "block";
    theObj.filters["DXImageTransform.Microsoft.RandomDissolve"].Play();

}

/*BREAK*/
/* returns &nbsp; as a place holder when necessary*/
Shared.CreatePlaceHolder = function (value, bReplaceSpaces) {

    value = Shared.Trim(value);
    var sReturn = value;
    
    if(value == "" || (bReplaceSpaces && value == " ") ) { sReturn = "&nbsp"; }
        
    return sReturn;

}

/*BREAK*/
/* Returns the current date in month/day/year format*/
Shared.GetDate = function () {

    return new Date().Format();

}
/*BREAK*/
/* accepts an array of values to be placed in columns,
   & the num of columns the table should have.*/
Shared.TableRowSetBuilder = function (arItems, ColumnCount) {

    var sTable = "";
    var cellCount = 0;
    
    for(var i = 0; i < arItems.length; i++) {
    
        cellCount++;
        
        if(cellCount == 1) { sTable += "<tr>"; }
        
        sTable += "<td>" + arItems[i] + "</td>";
        
        if(cellCount < ColumnCount && i == arItems.length - 1) {
        
            var iLeftOver = parseInt(ColumnCount - cellCount);
            sTable += "<td colspan = \"" + iLeftOver.toString() + "\"></td>";
            cellCount = ColumnCount;
        
        }
        
        if(cellCount == ColumnCount) { sTable += "</tr>"; cellCount = 0;}
    
    }
    
    return sTable;

}
/*BREAK*/
/* RETRIEVES THE OFFSET VALUE FOR THE GIVEN ELEMENT
                               false means get offsetleft, true means offsettop*/
Shared.GetOffset = function (element, bOffsetTop) {
        
    var offset = (bOffsetTop ? element.offsetTop : element.offsetLeft);
    var parent = element.offsetParent;
    var foundBody = false;
	
    while(!foundBody) {
    //try {
        //if(parent.innerHTML.indexOf("<HEAD>") > -1 || parent.tagName.toLowerCase() == "body") {foundBody = true; }
        var sTagName = parent.tagName.toLowerCase();
        if(sTagName == "body" || sTagName == "html") {foundBody = true; }
        else {
            offset += (bOffsetTop ? parent.offsetTop : parent.offsetLeft);
            parent = parent.offsetParent;
        }
        //}catch(x) {alert(element.offsetParent.innerHTML); foundBody = true;}
    }
	
    return offset;
}

Shared.GetElementPosition = function (element) {
    var result = new Object();
    result.x = 0;
    result.y = 0;
    result.width = 0;
    result.height = 0;
    if (element.offsetParent) {
        result.x = element.offsetLeft;
        result.y = element.offsetTop;
        var parent = element.offsetParent;
        while (parent) {
            result.x += parent.offsetLeft;
            result.y += parent.offsetTop;
            var parentTagName = parent.tagName.toLowerCase();
            if (parentTagName != "table" &&
                parentTagName != "body" && 
                parentTagName != "html" && 
                parentTagName != "div" && 
                parent.clientTop && 
                parent.clientLeft) {
                result.x += parent.clientLeft;
                result.y += parent.clientTop;
            }
            parent = parent.offsetParent;
        }
    }
    else if (element.left && element.top) {
        result.x = element.left;
        result.y = element.top;
    }
    else {
        if (element.x) {
            result.x = element.x;
        }
        if (element.y) {
            result.y = element.y;
        }
    }
    if (element.offsetWidth && element.offsetHeight) {
        result.width = element.offsetWidth;
        result.height = element.offsetHeight;
    }
    else if (element.style && element.style.pixelWidth && element.style.pixelHeight) {
        result.width = element.style.pixelWidth;
        result.height = element.style.pixelHeight;
    }
    return result;
}

// needed for backwards compatibility
Shared.MoveToCursor = function(elementToMoveTo, elementToMove, alignment, valign, bSkipAdjustment) {
    Shared.MoveToControl(elementToMoveTo, elementToMove, alignment, valign, bSkipAdjustment);
}

Shared.MoveToControl = function (elementToMoveTo, elementToMove, alignment, valign, bSkipAdjustment) {
    
    var iLeftPos;
    var iTopPos;
    
    alignment = ( alignment == null ? Alignment.Right : alignment );
    valign = ( valign == null ? Alignment.Bottom : valign );
    
    // private method used inside this method.
    function MoveItem(elementToMoveTo, elementToMove, align, valign) {
    
        iLeftPos = Alignment.CalculateHorizontal(align, elementToMoveTo, elementToMove);
        iTopPos = Alignment.CalculateVertical(valign, elementToMoveTo, elementToMove);
        
        if(valign == Alignment.Middle) {
        
            if(align == Alignment.Right) { iLeftPos += elementToMoveTo.offsetWidth; }
            else if(align == Alignment.Left) { iLeftPos -= elementToMoveTo.offsetWidth; }
        
        }
        
        elementToMove.style.left = (iLeftPos) + "px";
        elementToMove.style.top = (iTopPos) + "px";
    
    }
    
    
    MoveItem(elementToMoveTo, elementToMove, alignment, valign);
    
    if(bSkipAdjustment) { return; }

    if(Shared.ElementTooTallForWindow(elementToMove)) {
        // both x and y need adjusted
        if(Shared.ElementTooWideForWindow(elementToMove)) { Shared.ResizeWindow(elementToMove.offsetHeight + elementToMoveTo.offsetHeight, elementToMove.offsetWidth + elementToMoveTo.offsetWidth); }

        // just y needs adjusted
        else { Shared.ResizeWindow(elementToMove.offsetHeight + elementToMoveTo.offsetHeight, Shared.BrowserWidth()); }
    } else if(Shared.ElementTooWideForWindow(elementToMove)) {
        // just x needs adjusted
        Shared.ResizeWindow(Shared.BrowserHeight(), elementToMove.offsetWidth + elementToMoveTo.offsetWidth);
    }
    
    // determine if object is too far to any side.
    var tooFarRight = Shared.ElementTooFarRight(elementToMove);
    var tooFarLeft = Shared.ElementTooFarLeft(elementToMove);
    var tooHigh = Shared.ElementTooHigh(elementToMove);
    var tooLow = Shared.ElementTooLow(elementToMove);
        
    var iLoopMax = 3;
    var UsedHorizontalAligns = new Array(alignment);
    var UsedVerticalAligns = new Array(valign);
    
    var iLoopCount = UsedHorizontalAligns.length;
    
    
    while(tooFarRight) {
    
        alignment = Alignment.GetNewAlign(false, alignment);
        if(!Shared.ArrayContains(UsedHorizontalAligns, alignment, false)) { 
        
            UsedHorizontalAligns.push(alignment);
            
            MoveItem(elementToMoveTo, elementToMove, alignment, valign);
            
            tooFarRight = Shared.ElementTooFarRight(elementToMove);
            tooFarLeft = Shared.ElementTooFarLeft(elementToMove);
            if(!tooFarRight) { break; }
            
        }
        else if(iLoopCount == iLoopMax) { window.scroll(iLeftPos, iTopPos); break; }
        iLoopCount++;
    }
    
    iLoopCount = UsedHorizontalAligns.length;

    while(tooFarLeft) {
    
        alignment = Alignment.GetNewAlign(true, alignment);
        if(!Shared.ArrayContains(UsedHorizontalAligns, alignment, false)) { 
        
            UsedHorizontalAligns.push(alignment);
            
            MoveItem(elementToMoveTo, elementToMove, alignment, valign);
        
            tooFarLeft = Shared.ElementTooFarLeft(elementToMove);
            if(!tooFarLeft) { break; }
            
        }
        else if(iLoopCount == iLoopMax) { window.scroll(iLeftPos, iTopPos); break; }
        iLoopCount++;
    }
    
    iLoopCount = UsedVerticalAligns.length;
    
    while(tooHigh) {
    
        valign = Alignment.GetNewValign(true, valign);
        if(!Shared.ArrayContains(UsedVerticalAligns, valign, false)) { 
        
            UsedVerticalAligns.push(valign);
            
            MoveItem(elementToMoveTo, elementToMove, alignment, valign);
        
            tooHigh = Shared.ElementTooHigh(elementToMove);
            tooLow = Shared.ElementTooLow(elementToMove);
            if(!tooHigh) { break; }
            
        }
        else if(iLoopCount == iLoopMax) { window.scroll(iLeftPos, iTopPos); break; }
        iLoopCount++;
    }
    
    iLoopCount = UsedVerticalAligns.length;
    
    while(tooLow) {
    
        valign = Alignment.GetNewValign(true, valign);

        if(!Shared.ArrayContains(UsedVerticalAligns, valign, false)) { 
        
            UsedVerticalAligns.push(valign);
            
            MoveItem(elementToMoveTo, elementToMove, alignment, valign);
        
            tooLow = Shared.ElementTooLow(elementToMove);
            if(!tooLow) { break; }
            
        }
        else if(iLoopCount == iLoopMax) { window.scroll(iLeftPos, iTopPos); break; }
        iLoopCount++;
        var topScrollThreshhold = Shared.BrowserHeight() + Shared.ScrollTop();
        var bottomPos = Shared.GetOffset(elementToMove, true) + elementToMove.offsetHeight;
        //alert(topScrollThreshhold);
        //alert(bottomPos);
    }

}

Shared.PageHeight = function(DefaultValue) {

    var size;
    if (document.body && document.body.scrollHeight) { size = document.body.scrollHeight + "px"; }
    else if (document.body.offsetWidth) { size = document.body.offsetHeight + "px"; }
    else { size = DefaultValue || "100%"; }
    return size;

}

Shared.PageWidth = function(DefaultValue) {

    var size;
    if (document.body && document.body.scrollWidth) { size = document.body.scrollWidth + "px"; }
    else if (document.body.offsetWidth) { size = document.body.offsetWidth + "px"; }
    else { size = DefaultValue || "100%"; }
    return size;

}

// BROWSER HEIGHT RELATED METHODS ------------------------------------------------------------------
Shared.BrowserWidth = function() {

    var iWidth = null;

    /*if(window.innerWidth) { iWidth = parseInt(window.innerWidth); }
    else if(document.body.clientWidth) { iWidth = parseInt(document.body.clientWidth); }
    
    return iWidth;*/

    if (typeof (window.innerWidth) == 'number') {
        //Non-IE
        iWidth = window.innerWidth;
    } else if (document.documentElement && document.documentElement.clientWidth) {
        //IE 6+ in 'standards compliant mode'
        iWidth = document.documentElement.clientWidth;
    } else if (document.body && document.body.clientWidth) {
        //IE 4 compatible
        iWidth = document.body.clientWidth;
    }

    return parseInt(iWidth);
}

Shared.BrowserHeight = function () {

    var iHeight = null;
    /*
    if(window.innerHeight) { iHeight = parseInt(window.innerHeight); }
    else if(document.body.clientHeight) { iHeight = parseInt(document.body.clientHeight); }
    
    return iHeight;*/

    if (typeof (window.innerWidth) == 'number') {
        iHeight = window.innerHeight;
    } else if (document.documentElement && document.documentElement.clientHeight) {
        //IE 6+ in 'standards compliant mode'
        iHeight = document.documentElement.clientHeight;
    } else if (document.body && document.body.clientHeight) {
        //IE 4 compatible
        iHeight = document.body.clientHeight;
    }

    return parseInt(iHeight);

}

Shared.BrowserHeightOffset = function () {

    var iHeightAdd = 143;                       /* IE*/
            
    if(!document.body.filters) {                /* firefox*/
    
        iHeightAdd = 168;
        
    } /*else if(navigator.userAgent.toLowerCase().indexOf("safari") > -1) {
    
        iHeightAdd = 130;
    
    }*/
    return iHeightAdd;

}

Shared.BrowserWidthOffset = function () {

    var iWidthAdd = 30;
            
    if(!document.body.filters) {                /* firefox*/
    
        iWidthAdd = 10;
        
    } /*else if(navigator.userAgent.toLowerCase().indexOf("safari") > -1) {
    
        iWidthAdd = 20;
    
    }*/
    
    return iWidthAdd;

}

// END BROWSER HEIGHT RELATED METHODS --------------------------------------------------------------

// SCROLL RELATED METHODS --------------------------------------------------------------------------
Shared.ScrollLeft = function () {

    var iScroll = null;
    var iebody = ((document.compatMode && document.compatMode != "BackCompat") ? document.documentElement : document.body);

    if(typeof(window.pageXOffset) != "undefined") { iScroll = parseInt(window.pageXOffset); if(iScroll == null) { iScroll = 0; } }
    else if(typeof(iebody.scrollLeft) != "undefined") { iScroll = parseInt(iebody.scrollLeft); if(iScroll == null) { iScroll = 0; } }
    
    return iScroll;

}

Shared.HasHorizontalScroll = function () {

    var iebody = ((document.compatMode && document.compatMode != "BackCompat") ? document.documentElement : document.body);

    if(typeof(window.pageXOffset) != "undefined") { iScroll = parseInt(window.pageXOffset); if(iScroll == null) { return false; } else { return true; } }
    else if(typeof(iebody.scrollLeft) != "undefined") { iScroll = parseInt(iebody.scrollLeft); if(iScroll == null) { return false; } else { return true; } }
    
    return true;

}

Shared.ScrollBarOffset = function () {

    if(Shared.HasHorizontalScroll()) { return 20; }
    else { return 0; }

}

Shared.ScrollTop = function () {

    var iScroll = null;
    var iebody = ((document.compatMode && document.compatMode != "BackCompat") ? document.documentElement : document.body);
    
    if(typeof(window.pageYOffset) != "undefined") { iScroll = parseInt(window.pageYOffset); if(iScroll == null) { iScroll = 0; } }
    else if(typeof(iebody.scrollTop) != "undefined") { iScroll = parseInt(iebody.scrollTop); if(iScroll == null) { iScroll = 0; } }
    
    return iScroll;

}

// END SCROLL RELATED METHODS --------------------------------------------------------------------------

// METHODS DETERMINING IF ELEMENT IS TOO BIG FOR WINDOW, TOO FAR UP, DOWN, LEFT, OR RIGHT --------------

Shared.ElementTooFarLeft = function (element) {

    var leftScrollThreshhold = Shared.ScrollLeft();
    var rightPos = Shared.GetOffset(element, false);
    
    if(rightPos < leftScrollThreshhold) { return true; }
    return false;

}

Shared.ElementTooFarRight = function (element) {

    var leftScrollThreshhold = Shared.BrowserWidth() + Shared.ScrollLeft();
    var leftPos = Shared.GetOffset(element, false);
    var rightPos = leftPos + element.offsetWidth;
    
    if(rightPos > leftScrollThreshhold) { return true; }
    return false;

}

Shared.ElementTooWideForWindow = function (element) {

    //if(Shared.ElementTooFarRight(element) && Shared.ElementTooFarLeft(element)) { return true; }
    if(Shared.BrowserWidth() < element.offsetWidth) { return true; }
    return false;

}

Shared.ElementTooHigh = function (element) {

    var topScrollThreshhold = Shared.ScrollTop();
    var bottomPos = Shared.GetOffset(element, true);
    
    if(bottomPos < topScrollThreshhold) { return true; }
    return false;
}

Shared.ElementTooLow = function (element) {

    var topScrollThreshhold = Shared.BrowserHeight() + Shared.ScrollTop();
    var bottomPos = Shared.GetOffset(element, true) + element.offsetHeight;
    
    if(bottomPos > topScrollThreshhold) { return true; }
    return false;

}

Shared.ElementTooTallForWindow = function (element) {

    if(Shared.BrowserHeight() < element.offsetHeight) { return true; }
    //if(Shared.ElementTooHigh(element) && Shared.ElementTooLow(element)) { return true; }
    return false;

}

// END METHODS DETERMINING IF ELEMENT IS TOO BIG FOR WINDOW, TOO FAR UP, DOWN, LEFT, OR RIGHT --------------


// METHODS THAT RESIZE THE WINDOW --------------------------------------------------------------------------
Shared.ResizeWindowToElementSize = function (element) {

    if(typeof(element) == "string") { element = el(element); }
    var iPxFromTopOfItemToTopOfWindow = Shared.GetOffset(element, true) - Shared.ScrollTop();
    Shared.ResizeWindow(element.offsetHeight + (iPxFromTopOfItemToTopOfWindow) + Shared.ScrollBarOffset() + Shared.BrowserHeightOffset(), element.offsetWidth);
    //Shared.ResizeWindow(element.offsetHeight + Shared.GetOffset(element, true) + Shared.ScrollBarOffset(), element.offsetWidth);

}

Shared.ResizeWindow = function (iHeight, iWidth) {

    iHeight = parseInt(iHeight) + Shared.BrowserHeightOffset();
    iWidth = parseInt(iWidth) + Shared.BrowserWidthOffset();

    try {

        if(!isNaN(iHeight) && !isNaN(iWidth)) { window.resizeTo( iWidth, iHeight); }
        else { if(Debug) { alert("Something is not numeric!"); } }

    } catch(x){
    
        if(Debug) { alert(x.message); }
    
    }

}

Shared.GetAbsolutePositionedParent = function(element) {

    var parent = null;

    while (element != null) {

        try {

            var pos = Shared.GetStyle(element, "position");
            if (pos != null && pos.toLowerCase() == "absolute") { parent = element; break; }
        } catch (x) { }
        element = element.parentNode;

    }

    return parent;

}

Shared.IsAbsolutePositioned = function(element) {

    var parent = Shared.GetAbsolutePositionedParent(element);
    if (parent != null) { return true; }
    return false;

}

Shared.PageNameAndQueryString = function () {

    var arUrl = window.location.href.split('/');
    return arUrl[arUrl.length - 1];

}

Shared.PageName = function () {

    try
    {
        return PageNameAndQueryString().split('?')[0];
    }
    catch (x) { return ""; }

}

// END METHODS THAT RESIZE THE WINDOW --------------------------------------------------------------------------

/*BREAK*/
/*	Works with array sort to ensure that data is numerically sorted*/
function numberSort(n1, n2) { return NumberSort(n1, n2); }
function NumberSort(n1, n2) { 

	if(parseInt(n1) < parseInt(n2)) { retVal = -1;}
	else if(parseInt(n1) > parseInt(n2)) { retVal = 1; }
	else { retVal = 0; }
		
	return retVal;

}

/*Works with an array with a Date property to sort it by date.*/
/*HELPER FUNCTION MAY BE REQUIRED
function ReorderByDate(items) {

    var newList = new Array();
    var tmpInfo = new Array();
    
    function CreateSortableObject(index, date) {

        var o = new Object();
        o.Date = date;
        o.Index = index;
        return o;
    }
    
    for (var i = 0; i < items.length; i++) {

        tmpInfo.push(CreateSortableObject(i, items[i].Date));

    }

    tmpInfo.sort(DateSort);
    for (var i = 0; i < tmpInfo.length; i++) {

        newList.push(items[tmpInfo[i].Index]);

    }
    return newList;
}

*/
function DateSort(a, b) {

    var aDate = a.Date.split("/");
    var bDate = b.Date.split("/");
    var n1 = parseInt(aDate[2]) + parseInt(aDate[0]) + parseInt(aDate[1]);
    var n2 = parseInt(bDate[2]) + parseInt(bDate[0]) + parseInt(bDate[1]);
    return NumberSort(n1, n2);

}


/*  THESE FUNCTIONS ARE ONLY HERE FOR BACKWARDS COMPATIBILITY*/
function countDownChars(txtBoxID, objCountID, iLen) {

    Shared.CountDownChars(txtBoxID, objCountID, iLen);
    
}

function GetDate() {

    return Shared.GetDate();
    
}

function CreatePlaceHolder(value, bReplaceSpaces) {

    return Shared.CreatePlaceHolder(value, bReplaceSpaces);
    
}

function spaceTrim(sToTrim) {

    return Shared.SpaceTrim(sToTrim);

}

function escapeQuoteAndApos(sText) {

    return Shared.EscapeQuoteAndApos(sText);
    
}

function unEscapeQuoteAndApos(sText) {

    return Shared.UnEscapeQuoteAndApos(sText);
    
}

function IntToBool(integer) {

    return Shared.IntToBool(integer);
    
}

function BoolToInt(bool) {

    return Shared.BoolToInt(bool);
    
}
/*BREAK*/
function SetFilter(theObj, sDisplay) {

    Shared.SetFilter(theObj, sDisplay);

}
/*BREAK*/








//-------------------------------------------------------------------------------------------
//  -- METHODS AND PROPERTIES FOR ALIGNMENT OF OBJECTS ON PAGE
// ------------------------------------------------------------------------------------------
function Alignment() {}
Alignment.Center = "center";
Alignment.Left = "left";
Alignment.Right = "right";
Alignment.Top = "top";
Alignment.Bottom = "bottom";
Alignment.Middle = "middle";

Alignment.CalculateRight = function (elementToMoveTo) { return Shared.GetOffset(elementToMoveTo, false); }

Alignment.CalculateCenter = function (elementToMoveTo, elementToMove) {

    var iLeftPos = Alignment.CalculateRight(elementToMoveTo);
    iLeftPos -= parseInt(elementToMove.offsetWidth / 2);
    if(iLeftPos < 0) { iLeftPos = 0; }
    return iLeftPos;

}

Alignment.CalculateLeft = function (elementToMoveTo, elementToMove) {

    var iLeftPos = Alignment.CalculateRight(elementToMoveTo);
    iLeftPos += elementToMoveTo.offsetWidth - elementToMove.offsetWidth;
    if(iLeftPos < 0) { iLeftPos = 0; }
    return iLeftPos;

}

Alignment.CalculateHorizontal = function (align, elementToMoveTo, elementToMove) {

    align = (align != null ? Shared.Trim(align.toLowerCase()) : Alignment.Right);
    if(align == Alignment.Center) { return Alignment.CalculateCenter(elementToMoveTo, elementToMove); }
    else if(align == Alignment.Left) { return Alignment.CalculateLeft(elementToMoveTo, elementToMove); }
    else { return Alignment.CalculateRight(elementToMoveTo); }

}

Alignment.InitialTopPos = function (elementToMoveTo) { return Shared.GetOffset(elementToMoveTo, true); }

Alignment.CalculateTop = function (elementToMoveTo, elementToMove) {

    var iTopPos = Alignment.InitialTopPos(elementToMoveTo) - elementToMove.offsetHeight;
    if(iTopPos < 0) { iTopPos = 0; }
    return iTopPos;

}

Alignment.CalculateMiddle = function (elementToMoveTo, elementToMove) {

    var iTopPos = Alignment.InitialTopPos(elementToMoveTo) - parseInt(elementToMove.offsetHeight / 2);
    if(iTopPos < 0) { iTopPos = 0; }
    return iTopPos;

}

Alignment.CalculateBottom = function (elementToMoveTo) { return Alignment.InitialTopPos(elementToMoveTo) + elementToMoveTo.offsetHeight; }

Alignment.CalculateVertical = function (valign, elementToMoveTo, elementToMove) {

    valign = (valign != null ? Shared.Trim(valign.toLowerCase()) : Alignment.Bottom);
    if(valign == Alignment.Top) { return Alignment.CalculateTop(elementToMoveTo, elementToMove); }
    else if(valign == Alignment.Middle) { return Alignment.CalculateMiddle(elementToMoveTo, elementToMove); }
    else { return Alignment.CalculateBottom(elementToMoveTo); }

}

Alignment.GetNewAlign = function (tooFarLeft, currentAlignment) {
    
    // too far left
    if(tooFarLeft) {
    
        switch(currentAlignment) {
        
            case Alignment.Left:
                return Alignment.Center;
                break;
                
            case Alignment.Center:
                return Alignment.Right;
                break;
                
            default:
                return Alignment.Left;
                break;
        
        }
        
    
    // too far right
    } else {
    
        switch(currentAlignment) {
        
            case Alignment.Right:
                return Alignment.Center;
                break;
                
            case Alignment.Center:
                return Alignment.Left;
                break;
                
            default:
                return Alignment.Right;
                break;
        
        }
    
    }

}

Alignment.GetNewValign = function (tooHigh, currentValign) {

    // to high
    if(tooHigh) {
    
        switch(currentValign) {
        
            case Alignment.Top:
                return Alignment.Middle;
                break;
                
            case Alignment.Middle:
                return Alignment.Bottom;
                break;
                
            default:
                return Alignment.Top;
                break;
        
        }
    
    // too low
    } else {
    
        switch(currentValign) {
        
            case Alignment.Bottom:
                return Alignment.Middle;
                break;
                
            case Alignment.Middle:
                return Alignment.Top;
                break;
                
            default:
                return Alignment.Bottom;
                break;
        
        }
    
    }
        
}