// Set constants /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Check if browser is IE <7 ---------------------------------------------------
var rpToolbox_browserIsOldIE = rpToolbox_browserIsOldIE || (!window.XMLHttpRequest && window.ActiveXObject);

// Check if browser is IE ---------------------------------------------------
var rpToolbox_browserIsIE = window.ActiveXObject;

// Checks CSS compatiblity -----------------------------------------------------
var rpToolbox_CSS1Compat = (window.document.compatMode === "CSS1Compat");

// Prototype functions START ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

String.prototype.startsWith = function(str){
    return (this.indexOf(str) === 0);
};

String.prototype.endsWith = function(str){
    return (this.substring(this.length - str.length) === str);
};

String.prototype.contains = function(str){
    return (this.indexOf(str) !== -1);
};

String.prototype.cutFromEnd = function(slices){
    return this.substring(0, this.length - slices);
};

String.prototype.cutFromStart = function(slices){
    return this.substring(slices);
};

String.prototype.backSlashesToForward = function(){
    return this.replace(/\\/g, '/');
};

String.prototype.trailingSlashesToIndex = function(){
    return this.replace(/(\/"|\')/g, '/index.html$1');
};

String.prototype.removeTrailingSlash = function(){
    return this.replace(/\/$/, '');
};

String.prototype.addTrailingSlash = function(){
    return this.replace(/([^\/])$/, '$1/');
};

String.prototype.relativePathsToAbsolute = function(rootURL){
    return this.replace(/href=(\'|\")(?!http)/g, 'href=$1' + rootURL);
};

String.prototype.removePathEnd = function(){
    return this.substring(0, this.lastIndexOf('/') + 1);
};

// Prototype functions END ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// -- Get true pathname to current page ----------------------------------------
var realPathName = location.pathname.backSlashesToForward().replace(/ /g, '%20');

// -- Get the individual parts from the pathname to current page ---------------
var pathParts = realPathName.removeTrailingSlash().split("/");

// -- Makes displayed text look nicer by fx replacing '_' with ' ', and restoring mangeled characters from urls.
String.prototype.cleanUpText = function(){
    return unescape(this.replace(/_/g, ' ').replace(/#/g, ' - ').replace(/http:\/\//g, ''));
};

// -- removes 'empty' textnodes that FF & opera inserts and then chokes on
String.prototype.removeEmptyNodes = function(){
    return this.replace(/\B\s\B|[\n\r\t]/g, '');
};

// -- removes 'empty' textnodes that FF & opera inserts and then chokes on
function rpToolbox_removeEmptyNodes(parentNode){
    if (parentNode && !rpToolbox_browserIsIE) {
        parentNode.innerHTML = parentNode.innerHTML.removeEmptyNodes();
    }
    return parentNode;
}

// Returns value for an elements style rule ------------------------------------
function rpToolbox_getStyle(element, property){
    var value = "";
    if (window.document.defaultView && window.document.defaultView.getComputedStyle) {
        value = window.document.defaultView.getComputedStyle(element, null).getPropertyValue(property);
    }
    else 
        if (element.currentStyle) {
            value = element.currentStyle[property];
        }
    return value;
}

// Finders START /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Finds first element by classname -------------------------------------------------
function rpToolbox_getElementByClassName(className, parentNode, tagName){
    if (!parentNode) {
        parentNode = window.document;
    }
    if (!tagName) {
        tagName = "*";
    }
    var all = parentNode.getElementsByTagName(tagName);
    var element = null;
    for (var i = 0; i < all.length; i++) {
        if (all[i].className && (all[i].className.indexOf(className) !== -1)) {
            element = all[i];
            i = all.length;
        }
    }
    return element;
}

// Finds elements by classname -------------------------------------------------
function rpToolbox_getElementsByClassName(className, parentNode, tagName){
    if (!parentNode) {
        parentNode = window.document;
    }
    if (!tagName) {
        tagName = "*";
    }
    var all = parentNode.getElementsByTagName(tagName);
    var elements = [];
    for (var i = 0; i < all.length; i++) {
        if (all[i].className && (all[i].className.indexOf(className) !== -1)) {
            elements.push(all[i]);
        }
    }
    return elements;
}

// Find first link or a -tag with rel -------------------------------------------------
function rpToolbox_getLinkByRel(rel){
    var headNodes = document.getElementsByTagName('head')[0].getElementsByTagName('link');
    for (var h = 0; h < headNodes.length; h++) {
        if (headNodes[h].rel === rel) {
            return headNodes[h];
        }
    }
    var links = document.links;
    for (var i = 0; i < links.length; i++) {
        if (links[i].rel === rel) {
            return links[i];
        }
    }
    return null;
}

// Finders END ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Creators START ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Create an Element with id ------------------------------------------------
function rpToolbox_createElementWithId(type, id){
    var node = window.document.createElement(type);
    node.id = id;
    return node;
}

// Create an Element with classname and id------------------------------------------------
function rpToolbox_createElementWithClassNameAndId(type, className, id){
    var node = window.document.createElement(type);
    if (id) {
        node.id = id;
    }
    node.className = className;
    return node;
}

// Create an Element with id and text content ----------------------------------
function rpToolbox_createElementWithIDAndText(type, id, text){
    var node = window.document.createElement(type);
    if (id) {
        node.id = id;
    }
    node.appendChild(window.document.createTextNode(text));
    return node;
}

// Create a Link ---------------------------------------------------------------
function rpToolbox_createLinkWithHrefTextOnclickRel(href, text, onClick, rel){
    var wrapper = window.document.createElement("span");
    wrapper.innerHTML = '<a href="' + href + '" onclick="' + onClick + '" rel="' + rel + '">' + text + '</a>';
    return wrapper.firstChild;
}

function rpToolbox_createLink(href, text, rel, onClick){
    var wrapper = window.document.createElement("span");
    var content = '<a href="' + href + '"';
    if (onClick) {
        content += '" onclick="' + onClick + '"';
    }
    if (rel) {
        content += '" rel="' + rel + '"';
    }
    content += '>';
    if (text) {
        content += text;
    }
    content += '</a>';
    wrapper.innerHTML = content;
    return wrapper.firstChild;
}

// Create an Select ------------------------------------------------------------
function rpToolbox_createSelect(id, onChange){
    var wrapper = window.document.createElement("span");
    wrapper.innerHTML = '<select id="' + id + '" onchange="' + onChange + '" ></select>';
    return wrapper.firstChild;
}

// Create an option ------------------------------------------------------------
function rpToolbox_createOption(value, text){
    var option = window.document.createElement('option');
    option.value = value;
    option.appendChild(window.document.createTextNode(text));
    return option;
}

// Create an Input -------------------------------------------------------------
function rpToolbox_createInput(type, value, name, id, onClick){
    var wrapper = window.document.createElement("span");
    wrapper.innerHTML = '<input type="' + type + '" id="' + id + '" value="' + value + '" onclick="' + onClick + '" name="' + name + '"></input>';
    return wrapper.firstChild;
}

// Creators END //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Adds import css link to head ------------------------------------------------
function rpToolbox_addCSS(cssURL, parent){
    if (!parent) {
        parent = window.document.getElementsByTagName('head')[0];
    }
    var newStyleNode = window.document.createElement("link");
    newStyleNode.href = cssURL;
    newStyleNode.rel = "stylesheet";
    newStyleNode.type = "text/css";
    parent.appendChild(newStyleNode);
}

// Changes an elements id on mouseover -----------------------------------------
var rpToolbox_oldId = null;
function rpToolbox_changeIdOnMouseover(element, newId){
    element.onmouseover = function(){
        rpToolbox_oldId = this.id;
        this.id = newId;
    };
    element.onmouseout = function(){
        this.id = rpToolbox_oldId;
    };
}

// Changes an elements class on mouseover --------------------------------------
var rpToolbox_oldClass = null;
function rpToolbox_changeClassNameOnMouseover(element, newClass){
    element.onmouseover = function(){
        rpToolbox_oldClass = this.className;
        this.className = newClass;
    };
    element.onmouseout = function(){
        this.className = rpToolbox_oldClass;
    };
}

// Adds mouseover effects to childnodes -----------------------------------------
function rpToolbox_addMouseOverEffects(parentNodeId, className, newId){
    if (!className) {
        className = 'rpfx_mouseoverhighlights';
    }
    if (!newId) {
        newId = 'rpfx_mouseoverhilight';
    }
    var nodes;
    if (!parentNodeId) {
        nodes = rpToolbox_getElementsByClassName(className);
    }
    else {
        nodes = rpToolbox_getElementsByClassName(className, document.getElementById(parentNodeId));
    }
    for (var i = 0; i < nodes.length; i++) {
        var childNodes = rpToolbox_removeEmptyNodes(nodes[i]).childNodes;
        for (var n = 0; n < childNodes.length; n++) {
            rpToolbox_changeIdOnMouseover(childNodes[n], newId);
        }
    }
}

// Sets alternating odd/even classnames for childnodes --------------------
function rpToolbox_setOddEvenClasses(parentNodeId, className){
    if (!className) {
        className = 'rpfx_oddeven';
    }
    var nodes;
    if (!parentNodeId) {
        nodes = rpToolbox_getElementsByClassName(className);
    }
    else {
        nodes = rpToolbox_getElementsByClassName(className, document.getElementById(parentNodeId));
    }
    for (var i = 0; i < nodes.length; i++) {
        var childNodes = rpToolbox_removeEmptyNodes(nodes[i]).childNodes;
        for (var n = 0; n < childNodes.length; n++) {
            var childNode = childNodes[n];
            if (n % 2 !== 0) {
                childNode.className += ' rpfx_even';
            }
            else {
                childNode.className += ' rpfx_odd';
            }
        }
    }
}

// Set status ------------------------------------------------------------------
function rpToolbox_setStatus(status){
    if (!status) {
        status = ' &nbsp ';
    }
    document.getElementById("rp_status").innerHTML = status;
}

// -- Get real window height ------------------------------------
function rpToolbox_getWinHeight(){
    var height = 0;
    if (typeof(window.innerWidth) === 'number') {
        height = window.innerHeight;
    }
    else 
        if (document.documentElement && document.documentElement.clientHeight) {
            height = document.documentElement.clientHeight;
        }
        else 
            if (document.body && document.body.clientHeight) {
                height = document.body.clientHeight;
            }
    return height;
}

// -- Get real window width ------------------------------------
function rpToolbox_getWidth(){
    var width = 0;
    if (typeof(window.innerWidth) === 'number') {
        width = window.innerWidth;
    }
    else 
        if (document.documentElement && document.documentElement.clientWidth) {
            width = document.documentElement.clientWidth;
        }
        else 
            if (document.body && document.body.clientWidth) {
                width = document.body.clientWidth;
            }
    return width;
}

// IE fix START ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Fixes XMLHttpRequest for IE -------------------------------------------------
if (!window.XMLHttpRequest) {
    window.XMLHttpRequest = function(){
        return new window.ActiveXObject(window.navigator.userAgent.indexOf("MSIE 5") !== -1 ? "Microsoft.XMLHTTP" : "MSXML2.XMLHTTP");
    };
}
// Makes position: fixed work in IE --------------------------------------------
function rpToolbox_fixIEPositionFixed_step2(element){
    var value;
    if (rpToolbox_getStyle(element, 'position') === 'fixed') {
        element.style.position = 'absolute';
        if (rpToolbox_getStyle(element, 'top').endsWith('px')) {
            value = rpToolbox_getStyle(element, 'top').replace('px', '');
            element.style.setExpression('top', '(rpToolbox_CSS1Compat ? window.document.documentElement.scrollTop : body.scrollTop) + ' + value);
        }
        else {
            if (rpToolbox_getStyle(element, 'bottom').endsWith('px')) {
                value = rpToolbox_getStyle(element, 'bottom').replace('px', '');
                element.style.setExpression('top', '(rpToolbox_CSS1Compat ? (window.document.documentElement.scrollTop + window.document.documentElement.clientHeight - offsetHeight) : body.scrollTop + body.clientHeight - offsetHeight) - ' + value + ' + "px"');
            }
        }
        if (rpToolbox_getStyle(element, 'left').endsWith('px')) {
            value = rpToolbox_getStyle(element, 'left').replace('px', '');
            element.style.setExpression('left', '(rpToolbox_CSS1Compat ? (window.document.documentElement.scrollLeft) : body.scrollLeft) + ' + value + ' + "px"');
        }
        else {
            if (rpToolbox_getStyle(element, 'right').endsWith('px')) {
                value = rpToolbox_getStyle(element, 'right').replace('px', '');
                element.style.setExpression('left', '(rpToolbox_CSS1Compat ? (window.document.documentElement.scrollLeft + window.document.documentElement.clientWidth - offsetWidth) : (body.scrollLeft + body.clientWidth - offsetWidth)) - ' + value + ' + "px"');
            }
        }
    }
}

function rpToolbox_fixIEPositionFixed(nodeClassOrId){
    if (rpToolbox_browserIsOldIE) {
        var elements;
        var i;
        window.document.body.parentNode.style.backgroundImage = 'url(".")';
        window.document.body.parentNode.style.backgroundAttachment = 'fixed';
        if (nodeClassOrId && document.getElementById(nodeClassOrId)) {
            rpToolbox_fixIEPositionFixed_step2(document.getElementById(nodeClassOrId));
        }
        else 
            if (nodeClassOrId && rpToolbox_getElementsByClassName(nodeClassOrId)) {
                elements = rpToolbox_getElementsByClassName(nodeClassOrId);
                for (i = 0; i < elements.length; i++) {
                    rpToolbox_fixIEPositionFixed_step2(elements[i]);
                }
            }
            else {
                elements = window.document.getElementsByTagName("*");
                for (i = 0; i < elements.length; i++) {
                    rpToolbox_fixIEPositionFixed_step2(elements[i]);
                }
            }
    }
}

// -- Hover anything workaround for pre 7 IE ------------------------------------
function rpToolbox_hoverAnything(parentNodeId, tagName){
    if (rpToolbox_browserIsOldIE) {
        var parentNode = window.document.getElementById(parentNodeId);
        var elements = parentNode.getElementsByTagName(tagName);
        for (var i = 0; i < elements.length; i++) {
            rpToolbox_changeClassNameOnMouseover(elements[i], 'hover');
        }
    }
}

// Bulk fix IE bugs ------------------------------------------------------------
function rpToolbox_fixIEBugs(){
    rpToolbox_fixIEPositionFixed();
}

// IE fix END //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// AJAX START //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Makes simple xmlHttpRequest without callback, payload or resulthandling ---
function rpToolbox_simpleAjaxReq(url, theMethod){
    var method;
    if (theMethod) {
        method = theMethod;
    }
    else {
        method = 'GET';
    }
    var req = new window.XMLHttpRequest();
    req.open(method, url, false);
    req.send(null);
}


// Loads data using xmlHttpRequest  --------------------------------------------
function rpToolbox_loadDataFromProxy_xmlHttpRequest(url, callbackMethodName, id, proxyURL){
    if (url.startsWith(window.document.location.protocol + "//" + window.document.location.hostname)) {
        proxyURL = null;
    }
    var callback;
    if (id) {
        callback = callbackMethodName + "(req.responseText,'" + id + "')";
    }
    else {
        callback = callbackMethodName + "(req.responseText)";
    }
    if (proxyURL !== null) {
        url = proxyURL + "?url=" + url;
    }
    var req = new window.XMLHttpRequest();
    req.open('GET', url, true);
    req.onreadystatechange = function(){
        if (req.readyState === 4) {
            eval(callback);
        }
    };
    req.send(null);
}

// Loads data via dynamic script node insertion --------------------------------
function rpToolbox_loadDataFromProxy_scriptNode(URL, callbackMethodName, id, proxyURL){
    var dataScriptNode = window.document.createElement("script");
    dataScriptNode.setAttribute("src", proxyURL + '?callback=' + callbackMethodName + '&id=' + id + '&url=' + URL);
    dataScriptNode.setAttribute("type", "text/javascript");
    window.document.getElementsByTagName('head')[0].appendChild(dataScriptNode);
}

// Creates content at the current url ------------------------------------------
function rpToolbox_RESTcreate(){
    var req;
    var url;
    function done(){
        if (req.readyState === 4 && req.status === 200) {
            if (location.pathname.charAt(location.pathname.length - 1) === '/') {
                document.location = url;
            }
            else {
                document.location = url + "/";
            }
        }
    }
    var idField = document.getElementById('id');
    if (idField.value === "") {
        document.getElementById('rp_status').innerHTML = '- You have to write something first -';
    }
    else {
        rpToolbox_setStatus('<div id="waitanim">&nbsp;</div>');
        if (idField === null) {
            url = location.pathname;
        }
        else {
            url = location.pathname + document.getElementById('id').value + "/";
        }
        req = new XMLHttpRequest();
        req.onreadystatechange = done;
        req.open('PUT', url, true);
        req.setRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT"); // Fixes IE cache problem
        req.send(null);
    }
}

// Updates the content at the current url --------------------------------------
function rpToolbox_RESTupdate(url, content){
    var req;
    function done(){
        if (req.readyState === 4 && req.status === 200) {
            location.reload();
        }
    }
    if (!content) {
        content = document.getElementById("itemcontent").value;
    }
    if (!url) {
        url = location.pathname;
    }
    rpToolbox_setStatus('<div id="waitanim">&nbsp;</div>');
    req = new XMLHttpRequest();
    req.onreadystatechange = done;
    req.open('PUT', url, true);
    req.setRequestHeader("Content-Type", "text/xml; charset=UTF-8");
    req.setRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT"); // Fixes IE cache problem
    req.send(content);
}

// Deletes the content at the current url --------------------------------------
function rpToolbox_RESTdelete(url, callback){
    var req;
	var done;
    if (!url) {
        url = location.pathname;
    }
    if (!callback && !url) {
        done = function(){
            if (req.readyState === 4 && req.status === 200) {
                document.location = '..';
            }
        };
    }
    else 
        if (!callback && url) {
            done = function(){
                if (req.readyState === 4 && req.status === 200) {
                    document.location.reload();
                }
            };
        }
        else {
            done = function(){
                if (req.readyState === 4 && req.status === 200) {
                    callback();
                }
            };
        }
    req = new XMLHttpRequest();
    req.onreadystatechange = done;
    req.open('DELETE', url, true);
    req.setRequestHeader("If-Modified-Since", "Sat, 1 Jan 2000 00:00:00 GMT"); // Fixes IE cache problem
    req.send(null);
}


// AJAX END ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Returns correct scrollTop ----------------------------------------------------------
function rpToolbox_getScrollTop(){
    return rpToolbox_CSS1Compat ? window.document.documentElement.scrollTop : window.document.body.scrollTop;
}

// Scroll page -----------------------------------------------------------------
function rpToolbox_scrolloffset(scrolloffset, delay){
    if (scrolloffset === 0) {
        window.document.body.style.marginBottom = '80px';
    }
    else {
        window.document.body.style.marginBottom = '1000px';
    }
    if (!delay) {
        delay = 100;
    }
    var header = document.getElementById('header');
    if (!scrolloffset || scrolloffset === 0) {
        if (header) {
            scrolloffset = rpToolbox_getStyle(header, 'height') || rpToolbox_getStyle(header, 'height');
        }
        else {
            scrolloffset = 0;
        }
    }
    scrolloffset = scrolloffset + '';
    scrolloffset = scrolloffset.replace(/px/, '');
    scrolloffset = scrolloffset.replace(/auto/, '');
    window.setTimeout("window.scrollBy(0, -5 - " + scrolloffset + ")", delay);
}

// Hides an element ------------------------------------------------------------
function rpToolbox_hideElement(element){
    if (element) {
        element.style.display = ('none');
    }
}

// Unhides an element ----------------------------------------------------------
function rpToolbox_showElement(element){
    if (element) {
        element.style.display = ('');
    }
}

// Hides elements --------------------------------------------------------------
function rpToolbox_hideElements(elements){
    for (var i = 0; i < elements.length; i++) {
        rpToolbox_hideElement(elements[i]);
    }
}

// Unhides elements ------------------------------------------------------------
function rpToolbox_showElements(elements){
    for (var i = 0; i < elements.length; i++) {
        rpToolbox_showElement(elements[i]);
    }
}

// Converts raw time to localized format ---------------------------------------
function rpComments_time2local(time){
    var date = new Date();
    date.setTime(time);
    //return date.toLocaleString();
    return date.toLocaleDateString() + "  " + date.toLocaleTimeString();
}

// Removes a classname -------------------------------------------------
function rpToolbox_removeClassName(node, className){
    var oldClasses = node.className;
    node.className = oldClasses.replace(className, '');
}

// Convert content in nodes to local date  -------------------------------------
function rpToolbox_timeNodes2local(){
    var nodes = rpToolbox_getElementsByClassName('rp_time');
    for (var i = 0; i < nodes.length; i++) {
        if (nodes[i].firstChild && nodes[i].firstChild.nodeValue) {
            rpToolbox_removeClassName(nodes[i], 'rp_time');
            nodes[i].firstChild.nodeValue = rpComments_time2local(nodes[i].firstChild.nodeValue);
        }
    }
}

// Finds a childnode witch id, classname or tagname matches an identifier ------
function rpToolbox_findNodeRecursive(parentNode, identifier){// Recursive helper function
    if (parentNode.id === identifier || parentNode.className === identifier || parentNode.nodeName.toLowerCase() === identifier) {
        return parentNode;
    }
    var childNodes = parentNode.childNodes;
    var foundNode = null;
    for (var i = 0; i < childNodes.length; i++) {
        foundNode = rpToolbox_findNodeRecursive(childNodes[i], identifier);
        if (foundNode) {
            return foundNode;
        }
    }
}

function rpToolbox_findNode(parentNode, identifier, count){// Main funtion
    var node = null;
    if (parentNode) {
        if (count > 1) {
            var childNodes = parentNode.childNodes;
            for (var i = 0; i < childNodes.length; i++) {
                var childNode = childNodes[i];
                if (childNode.className === identifier || childNode.nodeName.toLowerCase() === identifier) {
                    if (count === 1) {
                        return childNode;
                    }
                    count--;
                }
            }
        }
        node = rpToolbox_findNodeRecursive(parentNode, identifier);
    }
    return node;
}

function rpToolbox_replaceCallback(newNode){
    if (window.rpToolbox_linksEnhanced) {
        rpToolbox_enhanceLinks(newNode);
    }
    var anchorLinks = window.document.getElementById("anchorlinks");
    if (anchorLinks) {
        rpToolbox_addAnchorLinks(anchorLinks.parentNode.id, "maincontent", 75);
    }
}

// Finds a childnode by an path identifier -------------------------------------
function rpToolbox_findNodeByIdentifier(parentNode, identifier){
    var identifierParts = identifier.split(".");
    var foundNode = parentNode;
    for (var i = 0; i < identifierParts.length; i++) {
        var identifierPart = identifierParts[i];
        var count = 1;
        if (identifierPart.indexOf("[") !== -1) {
            count = parseInt(identifierPart.substring(identifierPart.lastIndexOf("[") + 1, identifierPart.lastIndexOf("]")), 10);
            identifierPart = identifierPart.substring(0, identifierPart.lastIndexOf("["));
        }
        foundNode = rpToolbox_findNode(foundNode, identifierPart, count);
    }
    return foundNode;
}

// Replaces a node with new content --------------------------------------------
function rpToolbox_replace(content, identifier){
    var oldNode = window.document.getElementById(identifier);
    var tempNode = window.document.createElement("span");
    tempNode.innerHTML = content;
    tempNode = rpToolbox_removeEmptyNodes(tempNode);
    if (!identifier.startsWith('_all')) {
        tempNode = rpToolbox_findNodeByIdentifier(tempNode, identifier);
    }
    if (tempNode && tempNode.firstChild) {
        oldNode.parentNode.replaceChild(tempNode.firstChild, oldNode);
        if (rpToolbox_replaceCallback) {
            rpToolbox_replaceCallback(oldNode);
        }
        // rpToolbox_enhanceContent(); // <=================================================================
    }
    else {
        oldNode.className = '';
        oldNode.replaceChild(window.document.createTextNode('Content not found'), oldNode.firstChild);
    }
}

// Adds all inserts ------------------------------------------------------------
var rpToolbox_insertNodeID = 0;
function rpToolbox_addInserts(proxyURL){
    var waitMessage = 'Importing content...';
    if (!proxyURL) {
        proxyURL = '';
    }
    var insertNodes = rpToolbox_getElementsByClassName("insert");
    var insertNode;
    for (var i = 0; i < insertNodes.length; i++) {
        insertNode = insertNodes[i];
        var wrapperNode = window.document.createElement('div');
        insertNode.parentNode.replaceChild(wrapperNode, insertNode);
        wrapperNode.className = 'insert';
        wrapperNode.appendChild(insertNode);
        if (insertNode.firstChild) {
            insertNode.firstChild.nodeValue = 'Importing ' + insertNode.firstChild.nodeValue;
        }
        else {
            insertNode.appendChild(window.document.createTextNode(waitMessage));
        }
        insertNode.className = 'loading';
        insertNode.title = 'Importing content from ' + insertNode.href + insertNode.title;
        if (!insertNode.id) {
            insertNode.setAttribute("id", "_all" + rpToolbox_insertNodeID++);
        }
        
    }
    for (var n = 0; n < insertNodes.length; n++) {
        insertNode = insertNodes[n];
        rpToolbox_loadDataFromProxy_xmlHttpRequest(insertNode.href, 'rpToolbox_replace', insertNode.id, proxyURL);
        //rpToolbox_loadDataFromProxy_scriptNode(insertNode.href, 'rpToolbox_replace', insertNode.id, proxyURL);
    }
}

// Fixes some stuff to make text look nice when inserted into html -------------
function rpToolbox_text2HTML(text){
    text = text.replace(/\n/g, ' <br/> ');
    return text;
}

// Converts text to xml dom ----------------------------------------------------
function rpToolbox_text2XML(text){
    var doc;
    if (window.ActiveXObject) {
        doc = new ActiveXObject("Microsoft.XMLDOM");
        doc.async = "false";
        doc.loadXML(text);
    }
    else {
        doc = new DOMParser().parseFromString(text, "text/xml");
    }
    return doc;
}

// Adds a function to window.onload event ----------------------------------------------------
function rpToolbox_addOnLoad(newOnload){
    if (window.onload) {
        var oldOnload = window.onload;
        window.onload = function(){
            newOnload();
            oldOnload();
        };
    }
    else {
        window.onload = newOnload;
    }
}

// -- Builds a windowtitle based on the path -----------------------------------
function rpToolbox_buildWindowTitle(title, splitPoint){
    if (!title) {
        title = 'Mats Svensson - Restful Path';
    }
    var barItem;
    var path = location.pathname;
    var splitIndex = path.indexOf(splitPoint);
    var barItems = path.substring(splitIndex).split("/");
    while (barItems.length > 0) {
        barItem = barItems.shift();
        if (barItem !== "") {
            title += "  -  ";
        }
        title += barItem.cleanUpText();
    }
    window.document.title = title;
}

// -- Highlights content matching last part of url -----------------------------
function rpToolbox_hiLiteSelection(){
    var container = rpToolbox_getElementsByClassName('text')[0];
    if (container) {
        var pathItems = location.pathname.removeTrailingSlash().split("/");
        var pathEnd = unescape(pathItems[pathItems.length - 1]);
        var selection;
        var index;
        if (pathEnd.match(/\[\d*?\]/g)) {
            selection = pathEnd.replace(/\[[\d|\D]*?\]/g, '');
            index = pathEnd.replace(/[\d|\D]*?\[(\d*?)\][\d|\D]*?/g, '$1') - 1;
        }
        else {
            selection = pathEnd;
            index = 0;
        }
        container.firstChild.innerHTML = container.firstChild.innerHTML.replace(/<[\d|\D]*?>/g, '').replace(new RegExp('((?:' + selection + '.*?){' + index + '})' + selection), '$1<span class="highlighted">' + selection + '</span>');
    }
}

// -- Transforms xml with xsl ----------------------------------------------
function rpToolbox_xslTransform(xmlText, xslText){
    var xml = rpToolbox_text2XML(xmlText);
    var xsl = rpToolbox_text2XML(xslText);
    var result;
    // IE
    if (window.ActiveXObject) {
        result = xml.transformNode(xsl);
    }
    // Mozilla, Firefox, Opera, etc.
    else 
        if (document.implementation && document.implementation.createDocument) {
            var xsltProcessor = new XSLTProcessor();
            xsltProcessor.importStylesheet(xsl);
            var wrapper = document.createElement('div');
            wrapper.appendChild(xsltProcessor.transformToFragment(xml, document));
            result = wrapper.innerHTML;
        }
    return result;
}

// Returns selected text on page ---------------------------------------------------
function rpToolbox_getSelectionText(){
    var selectionText = '';
    if (window.getSelection && window.getSelection().rangeCount > 0) {
        selectionText = window.getSelection().getRangeAt(0).toString();
    }
    else 
        if (document.selection) {//IE
            selectionText = document.selection.createRange().text;
        }
    return selectionText;
}

// Returns  parent node for selection ------------------------------------------------
function rpToolbox_getSelectionParentNode(){
    var node = null;
    if (window.getSelection) {
        node = window.getSelection().getRangeAt(0).startContainer;
        if (node.nodeType !== 1) {
            node = node.parentNode;
        }
    }
    else 
        if (document.selection) {//IE
            node = document.selection.createRange().parentElement();
        }
    return node;
}

// Returns position on page for selection ------------------------------------------------
function rpToolbox_getSelectionPosition(){
    var selectionPosition = 0;
    if (window.getSelection) {
        selectionPosition = window.getSelection().getRangeAt(0).startOffset;
        var startContainer = window.getSelection().getRangeAt(0).startContainer;
        var childNodes = window.getSelection().getRangeAt(0).startContainer.parentNode.childNodes;
        for (var i = 0; childNodes[i] !== startContainer && i < childNodes.length; i++) {
            if (childNodes[i].length) {
                selectionPosition += childNodes[i].length;
            }
            else {
                selectionPosition += childNodes[i].childNodes[0].length;
            }
        }
        //alert(window.getSelection().getRangeAt(0).startContainer.parentNode.childNodes.length > 1)
    }
    else 
        if (document.selection) {//IE
            var tempRange = document.body.createTextRange();
            tempRange.moveToElementText(document.selection.createRange().parentElement());
            tempRange.collapse(true);
            tempRange.setEndPoint("EndToStart", document.selection.createRange());
            selectionPosition = tempRange.text.length;
        }
    return selectionPosition;
}

// Returns source element for event ------------------------------------------------------
function rpToolbox_getEventSource(e){
    var element;
    if (!e) {// IE
        e = window.event;
    }
    if (e.target) {
        element = e.target;
    }
    else 
        if (e.srcElement) {
            element = e.srcElement;
        }
    if (element.nodeType === 3) { // Safari bug  workaround
        element = element.parentNode;
    }
    return element;
}

// Finds a childnode witch id or classname or tagname matches an path Part ------------
// Step 2
function rpToolbox_findNodeByPathPartRecursive(parentNode, pathPart){// Recursive helper function
    if (parentNode.id === pathPart || parentNode.className === pathPart || parentNode.nodeName.toLowerCase() === pathPart) {
        return parentNode;
    }
    var childNodes = parentNode.childNodes;
    var foundNode = null;
    for (var i = 0; i < childNodes.length; i++) {
        foundNode = rpToolbox_findNodeRecursive(childNodes[i], pathPart);
        if (foundNode) {
            return foundNode;
        }
    }
}

// Step 1
function rpToolbox_findNodeByPathPart(parentNode, pathPart, count){
    var node = null;
    if (parentNode) {
        if (count > 1) {
            var childNodes = parentNode.childNodes;
            for (var i = 0; i < childNodes.length; i++) {
                node = childNodes[i];
                if (node.className === pathPart || node.nodeName.toLowerCase() === pathPart) {
                    if (count === 1) {
                        return node;
                    }
                    count--;
                }
            }
        }
        node = rpToolbox_findNodeByPathPartRecursive(parentNode, pathPart);
    }
    return node;
}


// RESTful Path  START //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Finds a childnode by an (restful) path ------------------------------------------------
function rpToolbox_findNodeByPath(path, parentNode){
    if (!parentNode) {
        parentNode = document.body;
    }
    var pathParts = path.removeTrailingSlash().split("/");
    var foundNode = parentNode;
    for (var i = 0; i < pathParts.length; i++) {
        var pathPart = pathParts[i];
        var count = 1;
        if (pathPart.indexOf("[") !== -1) {
            count = parseInt(pathPart.substring(pathPart.lastIndexOf("[") + 1, pathPart.lastIndexOf("]")), 10);
            pathPart = pathPart.substring(0, pathPart.lastIndexOf("["));
        }
        foundNode = rpToolbox_findNodeByPathPart(foundNode, pathPart, count);
    }
    return foundNode;
}

// Returns the (Restful) path to a node ----------------------------------------------------
function rpToolbox_getPathToNode(currentNode){
    var path = '';
    var childNodes;
    var index;
    var indexText;
    while (currentNode.id !== "maincontent" && currentNode.className !== "index" && currentNode.parentNode.id !== "maincontent" && currentNode.nodeName.toLowerCase() !== 'a') {
        if (currentNode.id && currentNode.id.lastIndexOf('rpfx_') === -1) {// Match id
            currentNode.id = currentNode.id.replace(/(rpfx_\S*?\s)|(rpfx_\S*?$)/g, '');//remove effect triggering id's
            path = currentNode.id + "/" + path;
        }
        else 
            if (currentNode.className && currentNode.className.lastIndexOf('rpfx_') === -1) {// Match class name
                currentNode.className = currentNode.className.replace(/(rpfx_\S*?\s)|(rpfx_\S*?$)/g, '');//remove effect triggering classnames
                childNodes = currentNode.parentNode.childNodes;
                index = 0;
                indexText = "";
                for (var i = 0; i < childNodes.length; i++) {
                    if (childNodes[i].className === currentNode.className) {
                        index++;
                    }
                    if (childNodes[i] === currentNode) {
                        i = childNodes.length;
                        if (index > 1) {
                            indexText = "[" + index + "]";
                        }
                    }
                }
                path = currentNode.className + indexText + "/" + path;
            }
            else {// Match node name
                childNodes = currentNode.parentNode.childNodes;
                index = 0;
                indexText = "";
                for (var n = 0; n < childNodes.length; n++) {
                    if (childNodes[n].nodeName === currentNode.nodeName) {
                        index++;
                    }
                    if (childNodes[n] === currentNode) {
                        n = childNodes.length;
                        if (index > 1) {
                            indexText = "[" + index + "]";
                        }
                    }
                }
                path = currentNode.nodeName.toLowerCase() + indexText + "/" + path;
            }
        currentNode = currentNode.parentNode;
    }
    return path;
}

// RESTful Path  END ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

var rpToolbox_highLightElementByPath_oldColour = null;
// Highlights an element identified by a path ----------------------------------------
function rpToolbox_highLightElementByPath(path){
    var element = rpToolbox_findNodeByPath(path, document.getElementById('maincontent').childNodes[0]);
    if (element) {
        rpToolbox_highLightElementByPath_oldColour = element.style.backgroundColor;
        element.style.backgroundColor = '#E4EFFD';
    }
    return false;
}

// Un-highlights an element identified by a path ----------------------------------------
function rpToolbox_unHighLightElementByPath(path){
    var element = rpToolbox_findNodeByPath(path, document.getElementById('maincontent').childNodes[0]);
    if (element) {
        element.style.backgroundColor = rpToolbox_highLightElementByPath_oldColour;
    }
    return false;
}

// -- Bulk content enhancement----------------------------------------------
function rpToolbox_enhanceContent(){
    rpToolbox_setOddEvenClasses();
    rpToolbox_hiLiteSelection();
    rpToolbox_addMouseOverEffects();
    rpToolbox_buildWindowTitle();
}


// Navigation START ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Enhances external links --------------------------------------------------------
function rpToolbox_externalLink(link, openInNewWindow){
    if (link.href.indexOf(window.document.location.host) === -1) {
        if (openInNewWindow) {
            link.target = '_blank';
        }
        link.className += ' externallink';
        link.title += ' (External link)';
    }
    
}

// Adds functionality to links ----------------------------------------------------
var rpToolbox_linksEnhanced = false;
function rpToolbox_enhanceLinks(container){
    var links;
    if (!container) {
        links = document.links;
    }
    else {
        links = container.getElementsByTagName("a");
    }
    for (var i = 0; i < links.length; i++) {
        rpToolbox_externalLink(links[i]);
    }
    rpToolbox_linksEnhanced = true;
}

// Mark link to current page  ------------------------------------------------------
function rpToolbox_markCurrentPageLink(containerID){
    var container = null;
    if (containerID) {
        container = document.getElementById(containerID);
    }
    else {
        container = document.body;
    }
    if (container) {
        var path = realPathName + location.search;
        container.innerHTML = container.innerHTML.replace(path + '"', path + '" id="selected" ');
    }
}

// Appends list with anchor links --------------------------------------------------
function rpToolbox_appendAnchorLinks(anchorLinksList, contentContainer){
    var itemCount = 0;
    if (!anchorLinksList) {
        anchorLinksList = document.getElementById('anchorlinkslist');
    }
    if (anchorLinksList) {
        var elements = rpToolbox_removeEmptyNodes(contentContainer).getElementsByTagName("*");
        var nodeValue = '';
        var previousNodeValue = '';
        var listItem = document.createElement("li");
        for (var i = 1; i < elements.length; i++) {
            if (elements[i].tagName.toLowerCase().startsWith('h') && elements[i].id) {
                itemCount++;
                listItem = document.createElement("li");
                if (elements[i].firstChild.firstChild) { // if the text is in the H tag
                    nodeValue = elements[i].firstChild.firstChild.nodeValue;
                }
                else { // if the text is in the H tags child, fx a A
                    nodeValue = elements[i].firstChild.nodeValue;
                }
            }
            else 
                if (elements[i].tagName.toLowerCase() === 'div' && elements[i].id && elements[i].firstChild.tagName.toLowerCase().startsWith('h')) {
                    itemCount++;
                    listItem = document.createElement("li");
                    nodeValue = elements[i].firstChild.firstChild.nodeValue;
                }
            if (nodeValue && previousNodeValue !== nodeValue) {// Weed out double hits.
                listItem.appendChild(rpToolbox_createLink('#' + elements[i].id, nodeValue, '', 'rpToolbox_scrolloffset()'));
                anchorLinksList.appendChild(listItem);
            }
            previousNodeValue = nodeValue;
        }
    }
    return itemCount;
}

// Add list with anchor links -----------------------------------------------------
function rpToolbox_addAnchorLinks(contentContainerID, headline){
    var contentContainer;
    if (!contentContainerID) {
        contentContainer = document.getElementById('maincontent');
    }
    else {
        contentContainer = document.getElementById(contentContainerID);
    }
    if (contentContainer) {
        var anchorlinks = document.getElementById('anchorlinks');
        if (anchorlinks) {
            anchorlinks.parentNode.removeChild(anchorlinks);
        }
        var anchorLinksList = rpToolbox_createElementWithId('ul', 'anchorlinkslist');
        var itemCount = rpToolbox_appendAnchorLinks(anchorLinksList, contentContainer);
        if (!document.getElementById("presentationbar") && itemCount > 0) {
            anchorlinks = rpToolbox_createElementWithId('div', 'anchorlinks');
            if (!headline) {
                headline = 'On This Page';
            }
            anchorlinks.appendChild(rpToolbox_createElementWithIDAndText('h2', '', headline));
            anchorlinks.appendChild(anchorLinksList);
            var positionNode = document.getElementById('rp_anchorlinksposition');
            positionNode.parentNode.replaceChild(anchorlinks, positionNode);
        }
    }
}

// Builds a BreadCrumbNavigation bar based on the path ----------------------------
function rpToolbox_buildBreadCrumbNavigation(){
    var splitPoint;
    var path = location.pathname.removeTrailingSlash();
    var breadCrumbNavigation = rpToolbox_createElementWithId('ul', 'breadcrumbnavigation');
    var firstCrumb = rpToolbox_createElementWithId('li', 'firstcrumb');
    firstCrumb.innerHTML = '<a href="/" rel="xstart">Start</a>';
    breadCrumbNavigation.appendChild(firstCrumb);
    var splitIndex = path.indexOf(splitPoint);
    var barItems = path.substring(splitIndex).split('/');
    path = path.substring(0, splitIndex - 1) + '/';
    var barItem;
    var crumb;
    while (barItems.length > 0) {
        barItem = barItems.shift();
        if (barItem !== '') {
            crumb = document.createElement('li');
            crumb.innerHTML = '<a href="' + (path += unescape(barItem) + '/') + '">' + barItem.cleanUpText().substr(0, 30) + '</a>';
            breadCrumbNavigation.appendChild(crumb);
        }
    }
    if (breadCrumbNavigation.lastChild.id === 'firstcrumb') {
        breadCrumbNavigation.lastChild.id = 'onlycrumb';
    }
    else {
        breadCrumbNavigation.lastChild.id = 'lastcrumb';
    }
    return breadCrumbNavigation;
}

// Adds BreadCrumbNavigation bar based to a node -----------------------------------
function rpToolbox_addBreadCrumbNavigation(breadCrumbNavigation){
    var positionNode = document.getElementById('breadcrumbnavigation');
    if (positionNode) {
        positionNode.parentNode.replaceChild(breadCrumbNavigation, positionNode);
    }
}

// Adds dropdown menus to the breadcrumbnavigation, from sitemap -------------------
function rpToolbox_addLevelsToBreadCrumbNavigation(breadCrumbNavigation, siteMap){
    var siteMapNode = rpToolbox_createElementWithId("ul", "sitemap");
    siteMapNode.innerHTML = siteMap; //unescape(siteMap);
    siteMapNode = rpToolbox_removeEmptyNodes(siteMapNode);// Needed for FF
    var siteMapItems = siteMapNode.getElementsByTagName("li");
    var crumbs = breadCrumbNavigation.childNodes;
    var path = "";
    for (var c = 1; c < crumbs.length; c++) {
        path = path + pathParts[c] + "/";
        for (var n = 0; n < siteMapItems.length; n++) {
            if (siteMapItems[n].getElementsByTagName("ul")[0] && siteMapItems[n].getElementsByTagName("a")[0].getAttribute('href').endsWith(path)) {
                crumbs[c].appendChild(siteMapItems[n].getElementsByTagName("ul")[0].cloneNode(true));
                n = siteMapItems.length;
            }
        }
    }
}

// Builds a list with local links --------------------------------------------------
function rpToolbox_buildLocalLinks(breadCrumbNavigation){
    var localLinksNode = rpToolbox_createElementWithId("div", "locallinks");
    var list = document.createElement("ul");
    localLinksNode.appendChild(list);
    var localLinks;
    if (breadCrumbNavigation.lastChild.childNodes.length > 1 || breadCrumbNavigation.lastChild.previousSibling) {
        var crumbs = breadCrumbNavigation.childNodes;
        for (var i = crumbs.length - 1; i > 0; i--) {
            if (crumbs[i].childNodes.length > 1) {
                localLinks = crumbs[i].cloneNode(true);
                i = 0;
            }
        }
        list.appendChild(localLinks);
        var header = document.createElement("h2");
        header.appendChild(localLinks.firstChild);
        localLinks.insertBefore(header, localLinks.firstChild);
    }
    else {
        localLinks = "";
    }
    return localLinksNode;
}

// Add list with local links -------------------------------------------------------
function rpToolbox_addLocalLinks(localLinks){
    var positionNode = document.getElementById('rp_locallinksposition');
    if (positionNode) {
        positionNode.parentNode.replaceChild(localLinks, positionNode);
    }
}

// Loads sitemap using xmlHttpRequest ----------------------------------------------
function rpToolbox_getSitemapFromServer_xmlHttpRequest(url){
    var req = new XMLHttpRequest();
    req.open('GET', url, false);
    req.send(null);
    if (!req.getResponseHeader("Date")) {// Forces IE to reload if cache is stale
        var lastModified = req.getResponseHeader("Last-Modified");
        var newreq = new XMLHttpRequest();
        lastModified = lastModified ? lastModified : new Date(0);
        newreq.open("GET", url, false);
        newreq.setRequestHeader("If-Modified-Since", lastModified);
        newreq.send(null);
        if (newreq.status !== 304) {
            req = newreq;
        }
    }
    return req.responseText;
    
}

// Displays an extended path breadcrumb navigation -------------------------------------------
function rpToolbox_showExtendedPath(e){
    var positionNode = document.getElementById('extendedpathnavigation');
    if (positionNode) {
        var extendedPathNavigation = rpToolbox_createElementWithId('ul', 'extendedpathnavigation');
        extendedPathNavigation.className = 'extendedpath';
        positionNode.parentNode.replaceChild(extendedPathNavigation, positionNode);
        var parentNode = document.getElementById('maincontent');
        parentNode.onmouseover = '';
        parentNode.onmouseout = '';
        var sourceNode;
        var selectedText = rpToolbox_getSelectionText();
        if (selectedText) {
            sourceNode = rpToolbox_getSelectionParentNode();
        }
        else {
            sourceNode = rpToolbox_getEventSource(e);// Opera needs this
        }
        var path = rpToolbox_getPathToNode(sourceNode);
        if (selectedText && document.getElementById('maincontent').className !== 'text') {
            var indexText = "";
            var selectionPosition = rpToolbox_getSelectionPosition();
            var textBeforeSelection = sourceNode.innerHTML.replace(/<[\d|\D]*?>/g, '').substr(0, selectionPosition);
            var selectionOccurrance = textBeforeSelection.match(new RegExp(selectedText, "g"));
            if (selectionOccurrance) {
                indexText = "[" + (selectionOccurrance.length + 1) + "]";
            }
            path = path + "/" + selectedText + indexText + "/";
        }
        var barItems = path.split('/');
        path = '';
        var barItem;
        var crumb;
        while (barItems.length > 0) {
            barItem = barItems.shift();
            if (barItem !== '') {
                crumb = document.createElement('li');
                path += barItem + '/';
                crumb.innerHTML = '<a onmouseover="rpToolbox_highLightElementByPath(\'' + path + '\')" onmouseout="rpToolbox_unHighLightElementByPath(\'' + path + '\')" href="' + path + '">' + barItem.cleanUpText().substr(0, 30) + '</a>';
                extendedPathNavigation.appendChild(crumb);
            }
        }
    }
}

// Displays preview of an extended path breadcrumb navigation --------------------------------
function rpToolbox_showExtendedPathPreview(e){
    var positionNode = document.getElementById('extendedpathnavigation');
    if (positionNode) {
        var extendedPathNavigation = rpToolbox_createElementWithId('ul', 'extendedpathnavigation');
        extendedPathNavigation.className = 'extendedpathpreview';
        positionNode.parentNode.replaceChild(extendedPathNavigation, positionNode);
        var sourceNode = rpToolbox_getEventSource(e);
        var path = rpToolbox_getPathToNode(sourceNode);
        var barItems = path.split('/');
        path = '';
        var barItem;
        var crumb;
        while (barItems.length > 0) {
            barItem = barItems.shift();
            if (barItem !== '') {
                crumb = document.createElement('li');
                crumb.innerHTML = '<a href="' + (path += barItem + '/') + '" href="' + path + '">' + barItem.cleanUpText().substr(0, 30) + '</a>';
                extendedPathNavigation.appendChild(crumb);
            }
        }
        document.getElementById('maincontent').onmouseout = function(){
            document.getElementById('extendedpathnavigation').innerHTML = '';
        };
    }
}

// Initiate restful path functions  -----------------------------------------------
function rpToolbox_initRestfulPath(){
    var contentNode = document.getElementById('maincontent');
    if (contentNode.childNodes[0] && contentNode.childNodes[0].className !== "linklist" && contentNode.className !== 'text') {
        contentNode.className += ' restfulpathcontent';
        contentNode.onmouseup = rpToolbox_showExtendedPath;
        contentNode.onmouseover = rpToolbox_showExtendedPathPreview;
    }
}

// Navigation END //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Toolbox handling START //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// Adds javascript import node -------------------------------------------------
// Use in parent script to load this toolbox.
// Example: addJS("/js/toolbox.js");

function rpToolbox_addJS(jsURL, doc){
    if (!doc) {
        doc = document;
    }
    var newJsNode = doc.createElement("script");
    newJsNode.src = jsURL;
    newJsNode.type = "text/javascript";
    newJsNode.charset = document.charset;
    doc.getElementsByTagName('head')[0].appendChild(newJsNode);
}

// Runs callback function named 'importedCodeCallBack', if it exists -----------
// Use in parent script to run stuff that needs this toolbox.
// Example: function importedCodeCallBack(){ stuff }
if (window.rpToolbox_toolboxLoadedCallBack) {
    window.rpToolbox_toolboxLoadedCallBack();
}

// Marks that toolbox is already available -------------------------------------
var rpToolbox_toolboxLoaded = true;

//alert('toolbox loaded');
// Toolbox handling END ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////