source: gs3-extensions/seaweed-debug/trunk/src/Util.js@ 25160

/*
 * file: Util.js
 *
 * @BEGINLICENSE
 * Copyright 2010 Brook Novak  (email : [email protected]) 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 * @ENDLICENSE
 */
bootstrap.provides("Util");

/**
 * @function
 * Gets a text node or element in the document at a given pixel position.
 * 
 * @param Number x The X pixel relative to the window.
 * @param Number y The Y pixel relative to the window.
 * @return {Node} An Element or Text node which i at the given coordinates.
 */
var _getRenderedNodeAtXY = document.elementFromPoint ?
    /* Use native version if available */ 
    function(x, y) {
        //return document.elementFromPoint(x, y);
        switch(_engine) {
            case _Platform.GECKO:
            case _Platform.TRIDENT:
                return document.elementFromPoint(x, y);
                
            default:
                // Webkit / presto requires page coordinates instead of client/window coordinates
                var scrollPos = _getDocumentScrollPos();
                return document.elementFromPoint(x + scrollPos.left, y + scrollPos.top); // Opera can return text nodes
        }
        
        
    } : function(x, y) {

        var element = null;
        
        searchElement(docBody);
        
        return element;
        
        function searchElement(parent){
        
            // First search deeper nodes
            if (parent.childNodes.length > 0) {
                var child = parent.firstChild;
                while (child) {
                    if (searchElement(child))                     
                        return true;
                    child = child.nextSibling;
                }
                
            }
            
            // Test this node... if it is an element
            if (parent.nodeType == Node.ELEMENT_NODE && (parent.offsetLeft || parent.offsetLeft == 0)) {
            
                // Get the elements position in the window
                var pos = _getPositionInWindow(parent);
                
                // Then check to see if x/y is inside bounds
                if (y >= pos.y && y <= (pos.y + parent.offsetHeight) &&
                x >= pos.x &&
                x <= (pos.x + parent.offsetWidth)) {
                    // Search has finished
                    element = parent;
                    return true;
                }
                
            }
            
            return false;
            
        }
    
    };
    

/**
 * Gets that position of an element in the window.
 * Supports internal scroll panes - price being slower operation.
 *
 * @param {Object} ele The element to get the position for.
 *
 * @return {Object} The position of the given element {x,y}
 */
/*function _getPosInWndIntScrollSupport(ele){
    var left = 0, top = 0, parent = ele;
    
    do {
        if (parent.offsetLeft || parent.offsetTop) {
            left += parent.offsetLeft;
            top += parent.offsetTop;
        }
    } while (parent = parent.offsetParent);
    
    parent = ele;
    do {
        if (parent == docBody) break; // already handled in a cross-browser fashion
        if (parent.scrollLeft || parent.scrollTop) {
            left -= parent.scrollLeft;
            top -= parent.scrollTop;
        }
    } while (parent = parent.parentNode); // Notice here: going up parent nodes, not offsets
    // Get the document scroll
    var scrollPos = _getDocumentScrollPos();
    
    // Return coordinates relative to window (using scroll information)
    return {
        x: left - scrollPos.left,
        y: top - scrollPos.top
    };
}*/

/**
 * Gets the position of an element in the window.
 * Does not garuantee to support internal scrolls. However does support
 * main document scrolling.
 *
 * @param {Node} ele The element to get the position for.
 *
 * @return {Object} The position of the given element {x,y}
 */
function _getPosInWndFast (ele){

    var left = 0,
        top = 0,
        isFixed = 0; // True if encountered fixed element
        
    do {
        
        // Add pixel offset to parent
        if (ele.offsetLeft || ele.offsetTop) {
    
            if (ele == docBody) {
                if (!isFixed) {
                    // Gecko browsers can have negitive offsets for the document body
                    // if there is a border present.
                    left += Math.abs(ele.offsetLeft);
                    top += Math.abs(ele.offsetTop);
                }
            } else {
                left += ele.offsetLeft;
                top += ele.offsetTop;                
            }

        }
        
        // TODO: NEED TO COMPUTE IF FIXED VIA CLASS.. expensive to do every element...
        isFixed |= (ele.style && ele.style.position == "fixed");
        
    } while (ele = ele.offsetParent);
    
    if (!isFixed) {
        
        // Subtract the document scroll for non-fixed elements
        var scrollPos = _getDocumentScrollPos();
        
        left -= scrollPos.left;
        top -= scrollPos.top;
        
       
        // Observations:
        // IE Versions which already includes body border widths
        // IE8 Standards/Quirks
        // IE7 Quirks
        
        // IE Versions which do not include body border widths
        // IE7 Standards
        // IE 6 Standards
        if (_engine == _Platform.TRIDENT && _engineVersion < 8) {
        
            // Some IE verions do not add the body border in any of the offsets (body/immediate children).
            // To get the border thicknesses in IE you can query the client top/left which will not
            // be effected by scrollbars or margins.
            
            left += docBody.clientLeft;
            top += docBody.clientTop;
        }
            
    } 
        
    // Return coordinates relative to window
    return {
        x: left,
        y: top
    };
}

/**
 * @type Function
 * 
 * Gets the position of an element in the window.
 *
 * @param {Node} ele The element to get the position for.
 *
 * @return {Object} The position of the given element {x,y}
 */
var _getPositionInWindow = _getPosInWndFast;

/**
 * Inserts a specified DOM node after a reference element as a child of the 
 * reference element's parent node.
 *
 * @param {Node} newNode The dom node being inserted
 *
 * @param {Node} refNode The node after which newNode is inserted.
 *
 * @return {Node} newNode passed in
 */
function _insertAfter(newNode, refNode){
    var sib = refNode.nextSibling;
    if (!sib) 
        refNode.parentNode.appendChild(newNode);
    else 
        refNode.parentNode.insertBefore(newNode, sib);
    return newNode;
}

/**
 * Inserts a dom node at a given index.
 * 
 * @param {Node} parentNode The parent of the newly inserted node
 * @param {Node} newNode The dom node being inserted
 * @param {Number} index The zero-based index of where in the parents child list the new node should be added.
 */
function _insertAt(parentNode, newNode, index) {
    
    var i = -1;
    var node = parentNode.firstChild;
    
    while (++i != index && node) {
        node = node.nextSibling;
    }
    
    if (i == index) {
        if (i == parentNode.childNodes.length) parentNode.appendChild(newNode);
        else parentNode.insertBefore(newNode, node);
        
        return newNode;
    }
    
    return null;
}

/**
 * Returns the combined length of all the descendant text nodes of a given element
 *
 * @param {Node} ele A element to get the text length for
 * @return {Number} The text length for the given element
 */
function _getDeepTextLength(ele){
    var len = 0;
    _visitTextNodes(ele, true, function(textNode){
        len += _nodeLength(textNode);
    });
    return len;
}

/**
 * Clones all object members.
 * 
 * @param {Object} obj An object to clone
 * 
 * @return {Object} The cloned object.
 */
function _clone(obj) {
    var clone = {};
    for (var i in obj) clone[i] = obj[i];
    return clone;
}


/**
 * Traverses through DOM nodes and applies/maps a function to all nodes
 * 
 * @param {Node} root The parent to search from. Inclusive in search. Null to find the root automatically, 
 *                 up to and excluding the document node (if any).
 *
 * @param {Node} start The node at which the traversal should start from. This must be a child of parent, or the same as parent.
 *
 * @param {Boolean} searchRight True to traverse tree preorder from left to right, e.g. current, child1, child2, ...
 *                              False to traverse tree postorder from right to left, e.g. ... child2, child1, current
 * 
 * @param {RegExp} filter A regular expression - the function is only
 *                  applied to nodes whos names match the regular expression. If null is
 *                  supplied then all nodes are visited.
 *
 * @param {Function} func   The function to apply. One argument is given: the visting nodes.
 *                          Returning false aborts traversal. Returning 1 in right searches
 *                          skips traversing into the current node's children. Anything else returned
 *                          will be ignored and the traversal will continue.
 */
function _visitNodes(root, start, searchRight, filter, func) {

    // Ensure that root is set.
    if (!root)
        root = _getRoot(start, [Node.DOCUMENT_NODE, Node.DOCUMENT_FRAGMENT_NODE]);

    var startStack = _getAncestors(start, root, true, true);
    var stackIndex = startStack.length - 1;

    (function trav(parent) {
    
        var child, res, skipChildren = false;
        
        // Are we recursing to the starting node (building stack frame)?
        if (stackIndex > 0) { // before start point
        
            stackIndex--;
            child = searchRight ? startStack[stackIndex].nextSibling : startStack[stackIndex].previousSibling;
            if (!trav(startStack[stackIndex]))                 
                return false;
            
        } else if (stackIndex == 0) { // start point onwards
            
            // Map the function to the parent node if its node name isn't filtered out
            if (searchRight && (!filter || filter.test(_nodeName(parent)))) {
                res = func(parent);
                if (res === false)                      
                    return res;
                skipChildren = (res === 1); // Skip children?
            }
        
            // If we are traverse backwards (postorder + reverse sequence), then
            // dont traverse deeper from the start node... begin moving left/upward
            if (!searchRight && parent == start) child = null;
            else child = searchRight ? parent.firstChild : parent.lastChild;
        }

        // Search children
        if (!skipChildren) {
            while (child) {
                if (!trav(child))                     
                    return false;
                child = (searchRight) ? child.nextSibling : child.previousSibling;
            }
        }
    
        // Map the function to the parent node if its node name isn't filtered out
        if (!searchRight && (!filter || filter.test(_nodeName(parent))))
            if (func(parent) === false)
                return false;

        return true;
        
    })(root);

}

/**
 * Traverses through DOM nodes and applies/maps a function to text nodes.
 * 
 * The tree traversal is preorder. 
 * 
 * @param {Node} root The parent to search from. Inclusive in search. Null to find the root automatically.
 *
 * @param {Node} start The node at which the traversal should start from.
 *
 * @param {Boolean} searchRight True to traverse tree preorder from left to right, false to traverse from right to left.
 * 
 * @param {Function} func   The function to apply. One argument is given: the child text nodes.
 *                          Returning false aborts traversal.
 * 
 *
 */
function _visitTextNodes(root, start, searchRight, func) {
    _visitNodes(root, start, searchRight, /^#text$/, func);
}

/**
 * Traverses through DOM nodes and applies/maps a function to all nodes.
 * 
 * The tree traversal is preorder. 
 * 
 * @param {Node} root The parent to search from. Inclusive in search. Null to find the root automatically.
 *
 * @param {Node} start The node at which the traversal should start from.
 *
 * @param {Boolean} searchRight True to traverse tree preorder from left to right, false to traverse from right to left.
 * 
 * @param {Function} func The function to apply. One argument is given: the child nodes.
 *                      Returning false aborts traversal.
 */
function _visitAllNodes(root, start, searchRight, func) {
    _visitNodes(root, start, searchRight, null, func);
}

/**
 * Determines whether a node is an ansetor of another.
 * 
 * @param {Node} ancestor A dom node
 * 
 * @param {Node} descendant A dom node
 * 
 * @return {Boolean} True if ancestor is an ancestor of descendant
 */
function _isAncestor(ancestor, descendant) {
    descendant = descendant.parentNode;
    while (descendant) {
        if (descendant == ancestor)             
            return true;
        descendant = descendant.parentNode;
    }
    
    return false;
}

/**
 * Gets ancestors of a dom node.
 * 
 * @param {Node} child The node to get ancestors for.
 * 
 * @param {Node} endAncestor The last ancestor of the search. This can be null to get all ancestors
 * 
 * @param {Boolean} includeChild True to include the child in with the ancestors.
 * 
 * @param {Boolean} includeEndAncestor True to include the endAncestor in with the ancestors.
 * 
 * @return {Array} An array of dom Node's containinhg the ancestors. Ordered from child to ancestor
 */
function _getAncestors(child, endAncestor, includeChild, includeEndAncestor) {

    if (child == endAncestor) 
        return (includeChild || includeEndAncestor) ? [child] : [];

    var ancestors = includeChild ? [child] : [];
    
    var nd = child.parentNode;
    
    while (nd && nd != endAncestor) {
        ancestors.push(nd);
        nd = nd.parentNode;
    }
    
    if (includeEndAncestor && endAncestor && nd == endAncestor) 
        ancestors.push(endAncestor);
    
    return ancestors;
}

/**
 * Finds an ancestor for a child up to a given point with a specific condition.
 * 
 * @example
 * 
 * var firstOccuringBlock = _findAncestor(child, docBody, de.html.isBlockLevel, true);
 * 
 * @param {Node} child            The child node to begin search from (Inclusive)
 * 
 * @param {Node} endAncestorEx    (Optional) The ancestor of the child node to stop at, 
 *                                Null will search up to the dom tree root
 *                                
 * @param {Function} markFunc     (Optional) A function which tests a given dom node. Return true to
 *                                 mark the node for being the node to retrieve (depending on stopOnFirst argument). 
 *                                 False/null/undefined to continue the search.
 *                                 
 * @param {Boolean} stopOnFirst   (Optional) True to stop the search on the first encountered marked node, 
 *                                 False/null/undefined to continue search to find last occuring marked node in ancestor path.
 *                                 
 * @return {Node}                 The querried result - null if could not find
 */
function _findAncestor(child, endAncestorEx, markFunc, stopOnFirst) {
    
    var lastMarkedNode = null;
    
    while (child) {
        if (markFunc && markFunc(child)) {
            if (stopOnFirst)
                return child;
            lastMarkedNode = child;
        }
        if (child.parentNode == endAncestorEx)
            break;
        child = child.parentNode;
    }
    
    return markFunc ? lastMarkedNode : child;
}

/**
 * Gets the first common ancestor between two nodes.
 * 
 * @param {Node} node1 A dom node
 * 
 * @param {Node} node2 A dom node
 * 
 * @param {Boolean} inclusive True to count node1 and node2 as being a possible common ancestor.
 * 
 * @return {Node} the first common ancestor between two nodes. Null if they share no ancestor.
 */
function _getCommonAncestor(node1, node2, inclusive){
    
    var ancestors1 = _getAncestors(node1, null, inclusive, 1),
        ancestors2 = _getAncestors(node2, null, inclusive, 1),
        commonParent = null;
    
    for (var i in ancestors1) {
        for (var j in ancestors2) {
            if (ancestors1[i] == ancestors2[j]) {
                return ancestors1[i];
            }
        }
    }
    
    return null;
}

/**
 * Gets the next node in the preorder/postorder traversal.
 * 
 * @param {Node} node The reference point.
 * 
 * @param {Boolean} searchRight True to traverse tree preorder from left to right, false to traverse postorder from right to left.
 * 
 * @return {Node} The next node. Null if none exists.
 * 
 */
function _nextNode(node, searchRight) {
    var next = null;

    _visitNodes(null, node, searchRight, null, function(nd) {
        if (nd == node) return true; // Skip starting node
        next = nd;
        return false;
    });
    
    return next;
}

/**
 * @param {Node} node                The node to get the root for. Must not be null.
 * 
 * @param {[Number]} untilNodeTypes  Optional, an aray of DOM Node constants. If given, the search for the
 *                                   root node will stop just before the first encountered given node type.
 *                                   For example. [Node.DOCUMENT_NODE] will retreive up to the body element if
 *                                   it has a document node ancestor.
 *                                 
 * @return {Node}                    the root of the given node
 */
function _getRoot(node, untilNodeTypes) {
    
    while (node.parentNode){
        if (untilNodeTypes) {
            for (var i in untilNodeTypes) {
                if (node.parentNode.nodeType == untilNodeTypes[i]) 
                    return node;
            }
        }
        node = node.parentNode;
    }
    return node;
}

/**
 * Gets a dom nodes child index in its parents childrens node list
 * 
 * @param {Node} node A dom node
 * 
 * @return {Number} The zero-based index of where the node occurs in its parent chilren.
 *          -1 if has no parent
 */
function _indexInParent(node) {
    var index = -1;
    while (node) {
        index++;
        node = node.previousSibling;
    }
    return index;
}

   

/**
 * Returns a string so that special reserved entities and white spaces are escaped.
 * Note that only whitespaces are escaped if they need to be....
 * 
 * @param {String} text The text to escape.
 * 
 * @param {Boolean} breakNewLines True to replace newline charactors with line breaks. False to treat as whitespace
 * 
 * @return {String} The escaped version of text.
 */
function _escapeTextToHTML(text, breakNewLines) {
    
    var escapedText = "";
    var start = 0;
    var c, i;
    
    for (i = 0; i < text.length; i++) {
        c = text.charAt(i);
        
        var escapedStr = null;
        
        switch(c) {
            case "\"":
                escapedStr = "&quot;";
                break;
            case "'":
                escapedStr = "&#39;"; // &apos; does not work in IE
                break;
            case "&":
                escapedStr = "&amp;";
                break;
            case "<":
                escapedStr = "&lt;";
                break;
            case ">":
                escapedStr = "&gt;";
                break;
            default:
                if (breakNewLines && c == "\n") {
                    escapedStr = "<br>";
                    
                } else if (_isAllWhiteSpace(c) && 
                    (i == 0 || 
                    i == (text.length - 1) ||
                    text.charAt(i-1) == " " || 
                    text.charAt(i+1) == " ")) {
                    escapedStr = "&nbsp;";
                }
        }
        
        // Does this charactor need escaping?
        if (escapedStr) {
            // First append charactors that are previously ok
            if ((i - start) > 0) {
                escapedText += (text.substring(start, i));
            }
            
            // Add the escaped version
            escapedText += escapedStr;
            
            // reset the start
            start = i + 1;
        }
    }

    // Add remaining text
    if ((i - start) > 0) {
        escapedText += (text.substring(start, i));
    }
    
    return escapedText;
    
}


/**
 * 
 * @param {String} htmlText The html string to parse
 * 
 * @return {String} The escaped version of text.
 */
function _parseHTMLString(htmlText) {
    
    var tmp = $createElement("span");
    tmp.innerHTML = htmlText;
    return tmp.firstChild.nodeValue;

}

/**
 * Determines whether a node is displayed or not depending on its immediate or inherited 
 * CSS display style. Note, that if a node's visibility is hidden, is does not mean
 * it is not displayed.
 * 
 * @param {Node} node A dom node to test
 * 
 * @return {Boolean} True if the dom node is displayed, false if it is not.
 */
function _isNodeDisplayed(node){
    while(node) {
        if (node.nodeType == Node.ELEMENT_NODE) {
            if (node.style.display == "none") 
                return false;
        }
        node = node.parentNode;
    }
    return true;
}

/**
 * Retreives a CSS style directly set for or inherited by a given dom node.
 * 
 * @see www.quirksmode.org/dom/getstyles.html
 * 
 * @param {Node} node         A dom node.
 * @param {String} styleProp  A CSS style property, formatted in CSS notation.
 * @return {String}           The inherited style of the given node. Undefined if the node does not have the style.
 *                            If the node is not an element, then the first ancestor element is selected.
 *                 
 */
function _getComputedStyle(node, styleProp) {
    
    while (node && node.nodeType != Node.ELEMENT_NODE) {
        node = node.parentNode;
    }
    if (!node) return;
    
    if (window.getComputedStyle)  // DOM Spec
       return document.defaultView.getComputedStyle(node,"").getPropertyValue(styleProp)
       
    else if (node.currentStyle)  // MS HTML
        return node.currentStyle[_styleCSSToJSNotation(styleProp)];
    
    debug.println("Warning - could not get style \"" + styleProp + "\" for a \"" + node.nodeName + "\" element");
    // Otherwise undefined...
}

/**
 * Sets an element's CSS string
 * @param {Node} ele     An element node
 * @param {String} css   A css style string formatted in CSS notation.
 * 
 * @example
 *     _setFullStyle(myElement, "color:red; padding:4px; font-size:12px");
 */
function _setFullStyle(ele, css){
    if (_engine == _Platform.TRIDENT) 
        ele.style.setAttribute("cssText", css);
    else 
        ele.setAttribute("style", css);
}

/**
 * Sets a CSS style value for a given element
 * 
 * @param {Node} ele    An element node
 * 
 * @param {String} css  The CSS style to set in JS Notation
 * 
 * @param {String} val  The value of the new style
 */
function _setStyle(ele, css, val) {
    if (_engine == _Platform.TRIDENT) 
        ele.style.setAttribute(css, val);
    else 
        ele.style[css] = val;
}

/**
 * Retrieves the full CSS markup for an elements style. Note that this is not the
 * computed markup - it is the explicitely assigned CSS for the particular node.
 * 
 * @param {Node} ele  The element to get the style from
 * @return {String}   The CSS for the given element. Never null, empty if no explicit styles set
 */
function _getFullStyle(ele) {
    return (_engine == _Platform.TRIDENT ? ele.style.getAttribute("cssText") : ele.getAttribute("style")) || "";
}

/**
 * @param {Element} ele The element to check
 * @return {Boolean} Evaluates to true iff the element has an element-level style 
 *                     (i.e not computed).
 */
function _doesHaveElementStyle(ele) {
    
    var fs = _getFullStyle(ele);
    
    // Check if the CSS text contains non-empty style-values
    if (fs) {
        fs = fs.split(";");
        for (var s in fs) {
            var idx = fs[s].indexOf(':');
            if (idx > 0 &&
            idx < (fs[s].length - 1) &&
            /\s*\S+\s*/.test(fs[s].substr(idx)))                 
                return 1;
        }
    }
}
        
/**
 * @param {String} styleProp A CSS style in JS notation.
 * @return {String} The given CSS style in CSS notation.
 */
function _styleJSToCSSNotation(styleProp) {
    do {
        var match = /([A-Z])/.exec(styleProp);
        if (match)
            styleProp = styleProp.substr(0, match.index) + "-" + match[1].toLowerCase() + styleProp.substr(match.index+1);
    } while(match);
    
    return styleProp;
};

/**
 * @param {String} color A CSS Style color. Can be in hex, rgb, percentages or actual names.
 *                       NOTE: Only supports converting the 16 standardized HTML color names - 
 *                      unstandard color names will return white.
 *                       
 * @return {[Number]} An array with elements R,G and B respectively. They range from 0-255.
 * 
 * DEPRECIATED
 */
var _getColorRGB = function() {
    
        var colorRegExp = /^\s*rgb\s*\(\s*(\d+)\%?\s*\,\s*(\d+)\%?\s*\,\s*(\d+)\%?\s*\)\s*$/i, 
        
        /* Only going to support the 16 standardized colors. All major browsers support a lot more but will seriously bloat the api size. */
        colorWMap = {
            maroon: [128,0,0],
            red: [255,0,0],
            orange: [255,165,0],
            yellow: [255,255,0],
            olive: [128,128,0],
            purple: [128,0,128],
            fuchsia: [255,0,255],
            white: [255,255,255],
            lime: [0,255,0],
            green: [0,128,0],
            navy: [0,0,128],
            blue: [0,0,255],
            aqua: [0,255,255],
            teal: [0,128,128],
            black: [0,0,0],
            silver: [12,12,12],
            gray: [128,128,128]
        };
        
    return function(val){
    
        if (val.charAt(0) == "#")  {
            if (val.length < 7)
                val += "000000";
            // Convert to RGB
            return [parseInt(val.substr(1,2),16), parseInt(val.substr(3,2),16), parseInt(val.substr(5,2),16)];
        }
        
        // Is the color in the notation "rbg(r,b,g)" ?
        var match = colorRegExp.exec(val);
        if (match) {
        
            var r = parseInt(match[1]), g = parseInt(match[2]), b = parseInt(match[3]);
            
            if (val.indexOf("%") > -1) { // convert percentages to 255 range
                if (r > 100) r = 100; // clamp;
                r = (255 * r) / 100;
                if (g > 100) g = 100; // clamp;
                g = (255 * g) / 100;
                if (b > 100) b = 100; // clamp;
                b = (255 * b) / 100;
            } else { // Clamp 255 range
                if (r > 255) r = 255;
                if (g > 255) g = 255;
                if (b > 255) b = 255;
            }
            
            return [r,g,b];
        }
        
        return colorWMap[val.toLowerCase()] || [255,255,255];
    }
        
}();

/**
 * @param {String} cssStyle   A CSS Style to check
 * @param {String} val1       The value of a CSS style to compare (with val2)
 * @param {String} val2       The value of a CSS style to compare (with val1)
 * @return {Boolean}          True if val1 is equivalent to val2 CSS
 * 
 * DEPRECIATED
 * 
 */
var _isCSSValueSame = function(){
    
    var fontWeightMap = {
        bold: "700",
        normal: "400"
    };
    
    function normalizeFontWeight(val){
        return fontWeightMap[val.toLowerCase()] || val;
    }
    
    
    return function(cssStyle, val1, val2){
    
        switch (cssStyle) {
            case "backgroundColor":
            case "borderColor":
            case "outlineColor":
            case "color":
                val1 = _getColorRGB(val1);
                val2 = _getColorRGB(val2);
                return val1[0] == val2[0] && val1[1] == val2[1] && val1[2] == val2[2];
                
            case "fontWeight":
                val1 = normalizeFontWeight(val1);
                val2 = normalizeFontWeight(val2);
                break;
        }
        
        return val1 == val2;
        
    };

}();

/**
 * @param {String} styleProp   A CSS style in CSS notation.
 * @return {String}            The given CSS style in JS notation.
 */
function _styleCSSToJSNotation(styleProp) {
    do {
        var index = styleProp.indexOf("-");
        if (index > -1)
         styleProp = (index == (styleProp.length-1)) ? 
            styleProp.substr(0, index) :
            styleProp.substr(0, index) + styleProp.charAt(index+1).toUpperCase() + styleProp.substr(index + 2);
    } while(index > -1);
    return styleProp;
};



/**
 * Gets the outer HTML content of a given element. 
 * NOTE: Can be expensive for large DOM Trees in firefox/konqueror.
 * @param {Node} node   An Element to get it's outer HTML for.
 * @return {String}     The outer html of the given node.
 */
function _getOuterHTML(node) {
    if (node.outerHTML) return node.outerHTML;
    else { // Firefox / konqueror
        var tmp = $createElement("span");
        tmp.appendChild(node.cloneNode(true));
        return tmp.innerHTML;
    }
}
   
/**
 * @return {Boolean} True if this browser allows you to safely extend the DOM.
 */
function _isDOMExtendable() {
    /* IE Versions 7 down are not core javascript. */
    return !(_browser == _Platform.IE && _browserVersion < 8);
}

/**
 * @param {Node}    node The node to extract the class name from
 * @param {RegExp}  A regular expression.
 * @return {String} the first occurring classname of the node which matches regexp. 
 *                  Null if did not find a match
 */
function _findClassName(node, regexp){
    if (node.nodeType == Node.ELEMENT_NODE || node == docBody) {
        var clsName = _getClassName(node);
        if (clsName) {
            var classNames = clsName.split(' ');
            for (var i in classNames) {
                if (regexp.test(classNames[i]))                     
                    return classNames[i];
            }
        }
    }
    return null;
}

/**
 * @param {Node} element A Dom element
 * @return {String} The class name for the given element
 */
function _getClassName(element) {
    return element.className;
}

/**
 * @param {Node} element  A Dom element
 * @param {String} name   The class to set - overrides all classes.
 */
function _setClassName(element, name) {
    return _browser == _Platform.IE ? element.setAttribute("className", name) : 
        element.className = name;
}

/**
 * Not all browsers support Array.indexOf .. this is a manual impl.
 * 
 * @param {Object} obj     An object
 * @param {Array} arr      An array
 * @return {Number} The    index of obj in arr. -1 if obj is not in arr.
 */
function _indexOf(obj, arr) {
    for (var i in arr) {
        if (arr[i] == obj) 
            return parseInt(i);
    }
    return -1;
}

/**
 * @param {Node} node a dom node
 * @return {String} The dom node's name in lower case
 */
function _nodeName(node) {
    return node.nodeName.toLowerCase();
}

/**
 * Determines whether a node is a text node and returns the text length if it is.
 * 
 * @param {Node} node            The dom node to test
 * 
 * @param {Object} defaultValue  (optional) If the node to test is not a text node then this value will be returned instead.
 *                               Defaults to NULL.
 * 
 * @return {Object}              If the node is a text node, then the text length of the node will be returned.
 *                               Otherwise defaultValue will be returned.
 */
function _nodeLength(node, defaultValue) {
    if (typeof defaultValue == "undefined")
        defaultValue = null;
    return node.nodeType == Node.TEXT_NODE ? node.nodeValue.length : defaultValue;
}

/**
 * Determines if an object is a DOM Node or not.
 * @param {Object} obj The object to test
 */
function _isDOMNode(obj){

    // @DEBUG ON
    // In debug mode, the Node object will be created if it is not available - in order to provide
    // node type constants. To distinuish from a real node object and the fabricaed one, test if the
    // _DE_DEBUG_CREATED if there
    if (Node._DE_DEBUG_CREATED)         
        return typeof obj == "object" && typeof obj.nodeType == "number" && typeof obj.nodeName == "string";
    // @DEBUG OFF
    
    return typeof Node == "object" ? obj instanceof Node : (typeof obj == "object" && typeof obj.nodeType == "number" && typeof obj.nodeName == "string");
};

/*
 * Expose internals to public
 */
$extend(de, {
    
    /**
     * Exposure of _visitAllNodes internal
     * @see _visitAllNodes
     */
    visitAllNodes : _visitAllNodes,
    
    getCommonAncestor : _getCommonAncestor,
    
    /**
     * @param {Node} node a dom node
     * @return {String} The inner text of the given node, never null, but can be empty.
     */
    getInnerText : function(node) {
        if (node.nodeType == Node.TEXT_NODE) 
            return node.nodeValue;
        return node.innerText || node.textContent || "";
    },
    
    /**
     * Exposure of _parseHTMLString internal
     * @see _parseHTMLString
     */
    parseHTMLString : _parseHTMLString,
    
    /**
     * Exposure of _insertAfter internal
     * @see _insertAfter
     */
    insertAfter : _insertAfter,
    
    /**
     * Exposure of _insertAt internal
     * @see _insertAt
     */
    insertAt : _insertAt,

    /**
     * Exposure of _findClassName internal
     * @see _findClassName
     */
    findClassName : _findClassName,
    
    /**
     * Exposure of _getPositionInWindow internal
     * @see _getPositionInWindow
     */
    getPositionInWindow : _getPositionInWindow,
    
    getOuterHTML : _getOuterHTML,
    
    getComputedStyle : _getComputedStyle
    
});