/* UTILITY FUNCTIONS
   ----------------- */
   
/*  Function:   getElements(classname,tagname,root)   
    Purpose:    Convenience Method for Grabbing Elements
    Support:    PC Firefox, Mac Firefox, Mac Safari, IE6, IE7
    Example:    getElements(className, tagname, root) returns all elements which are members of a specified class
    ------------------------------------------------------------------------------------------------------------- */
    
    function getElements(classname, tagname, root){
        if(!root) root = document;
        else if (typeof root == "string") root = document.getElementById(root);
        if(!tagname) tagname = "*";
        var all = root.getElementsByTagName(tagname);
        if(!classname) return all;
        var elements = [];
        for(var i = 0; i < all.length; i++){
            var element = all[i];
            if(isMember(element,classname))
                elements.push(element)
        }
        return elements;
    }
    function isMember(element, classname){
        var classes = element.className;
        if(!classes) return false;
        if(classes ==classname) return true;
        var whitespace = /\s+/;
        if (!whitespace.test(classes)) return false;
        var c = classes.split(whitespace);
        for(var i = 0; i < c.length; i++)
            if (c[i] == classname) return true;
        return false;
    }
    
    
/*  Function:   runOnLoad(f)   
    Purpose:    Portable onload event handler registration
    Support:    PC Firefox, Mac Firefox, Mac Safari, IE6, IE7
    Example:    runOnLoad(yourFunctionName)
    --------------------------------------------------------- */
    function runOnLoad(f){
        if(runOnLoad.loaded) f();
        else runOnLoad.funcs.push(f);
    }
    runOnLoad.funcs = [];
    runOnLoad.loaded = false;
    runOnLoad.run = function() {
        if (runOnLoad.loaded) return;
        
        for(var i = 0; i < runOnLoad.funcs.length; i++){
            try{runOnLoad.funcs[i]();}
            catch(e) {}
        }
            
        runOnLoad.loaded = true;
        delete runOnLoad.funcs;
        delete runOnLoad.run;
    };
    if(window.addEventListener)
        window.addEventListener("load", runOnLoad.run, false);
    else if (window.attachEvent) 
        window.attachEvent("onload", runOnLoad.run);
    else window.onload = runOnLoad.run;

    
/*  Function:   getBrowser/getAgent()
    Purpose:    Utility for reading the navigator type
    Support:    PC Firefox, Mac Firefox, Mac Safari, IE6, IE7
    --------------------------------------------------------- */
    var jsVer = -1;
    
    function detectMacXFF() {if (navigator.userAgent.toLowerCase().indexOf('mac') != -1 && userAgent.indexOf('firefox')!=-1) return true; return false;}
    
    function getBrowser(obj) {
        var b=new Array("unknown", "unknown", "unknown", "unknown");
    
        (isEmpty(obj) ? brs=navigator.userAgent.toLowerCase() : brs=obj);
    
        if (brs.search(/msie\s(\d+(\.?\d)*)/) != -1) {
        // MS Internet Explorer
            b[0]="msie";
            b[1]=getMSIEVersion();
            b[2]="msie";
            b[3]=b[1];
            return b;
        } 
        else if (brs.search(/safari\/(\d)*/) != -1) {
        // Safari
            b[0]="safari";
            b[1]=brs.match(/safari\/(\d+(\.?\d*)*)/)[1];
            b[2]="khtml";
            b[3]=brs.match(/applewebkit\/(\d+(\.?\d*)*)/)[1];
            return b;
        } 
        else if (brs.search(/firefox[\/\s](\d+([\.-]\d)*)/) != -1) {
        // Firefox
            b[0]="firefox";
            b[1]=brs.match(/firefox[\/\s](\d+([\.-]\d)*)/)[1];
            b[2]="gecko";
            b[3]=getGeckoVersion();
            return b;
        } 
    }
    
    function getMajorVersion(v) {return (isEmpty(v) ? -1 : (hasDot(v) ? v : v.match(/(\d*)(\.\d*)*/)[1]))}
    function getMinorVersion(v) {return (!isEmpty(v) ? (!hasDot(v) ? v.match(/\.(\d*([-\.]\d*)*)/)[1] : 0) : -1)}
    function getMSIEVersion() {return brs.match(/msie\s(\d+(\.?\d)*)/)[1];}
    function getGeckoVersion() {return brs.match(/gecko\/([0-9]+)/)[1];}
    function getFullUAString(obj) {(isEmpty(obj) ? brs=navigator.userAgent.toLowerCase() : brs=obj); return brs;}
    function isEmpty(input) {return (input==null || input =="")}
    function hasDot(input) {return (input.search(/\./) == -1)}
    function getAgent(){
        var br=new Array(4);
        br=getBrowser();    
        switch(br[0]){
            case "firefox":
                if(detectMacXFF) return 'mac_firefox'; else return 'win_firefox';
                break;    
            
            case "safari":
                return 'mac_safari';
                break;
                
            case "msie":
                return 'win_ie' + getMajorVerion(br[1]);
                break;    
        }
    }


/*  Function:   getStyle(htmlElement, some-dash-delimited-css-property)
    Purpose:    returns the computed style/value of a style property for an element
    Usage:      Send your html element or document node to this function as parameter 1, and a css property as parameter 2
    Example:    'getStyle(yourElement, border-top-color)' will return the value of the border-top-color for yourElement
    Support:    IE6, IE7, Safari (mac), Firefox( mac + PC)
    ----------------------------------------------------------------------------------------------------------------------- */
function getStyle(element, cssproperty){
    if(element.currentStyle){ 
    	/*internet explorer's alternative to computed styles*/
        try{
            var css2props = element.currentStyle;
            var cssProperty = convertToCamelCase(cssproperty);
            if( cssProperty in css2props ){
                var value = css2props[cssProperty];
                return value;
            }
        }
        catch(e){
            return;
        }
    } 
    else if (window.getComputedStyle){ 
    	/*firefox's syntax for reading computed styles*/
        var css2prop = window.getComputedStyle(element, null);
        var value = css2prop.getPropertyValue(cssproperty);
        if(value != null) return value;
    }
    else{
    	/*safari's syntax for reading computed styles*/
        try{
            var value = document.defaultView.getComputedStyle(element, null).getPropertyValue(cssproperty);
            return value;
        }
        catch(e){
            return;
        }
    }
}
/*end getStyle*/


/*  esmiling 20070613 
    Function:   convertToCamelCase(dash-del-mited-text)
    Purpose:    converts a dash delimited string to camelCase. This function is used by getStyle();
    Usage:      Send dash delimited text as a parameter, and its camelCase equivalent will be returned
    Support:    IE6, IE7, Safari (mac), Firefox( mac + PC)
    -------------------------------------------------------------------------------------------------- */
function convertToCamelCase(some_css_property){ 
    var words = some_css_property.split("-");
    var someCssProperty="";
    for(var i=0; i<words.length; i++){someCssProperty += words[i].charAt(0).toUpperCase() + words[i].slice(1);}
    someCssProperty = someCssProperty.charAt(0).toLowerCase() + someCssProperty.slice(1);
    return someCssProperty;
}

function isDescendantOf(ancestor, descendant){
    if(!ancestor || !descendant ) return false;
    var tagtype = descendant.nodeName;
    var allOfTagType = ancestor.getElementsByTagName(tagtype);
    for( var i = 0;  i < allOfTagType.length; i++ )
        if( allOfTagType[i] == descendant ) return true;    
    return false;
}
/************ END UTILITY FUNCTIONS ***************/