/*******
 ** vp - Utility functions, used by other objects **	
 *******/

/*******
 ** vp - $ :) - (c) Indivirtual 2008 - 1.0 **	
 *******/

function $() {
    var elements = new Array();
    for (var i=0; i<arguments.length; i++) {
        var element = arguments[i];
        if (typeof element == 'string') element = document.getElementById(element);
        if (arguments.length == 1) return element;
        elements.push(element);
    }
    return elements;
}

/*******
 ** vp - get elements of a certain kind - (c) Indivirtual 2008 - 1.0 **	
 *******/
getElementsByAttributeValue = function(attribute, value, root) {
    var output = new Array;
    var attributeName = (document.all && attribute.toLowerCase() == "class") ? "className" : attribute;
    var rootElement = root ? root : document;
    var els = (rootElement.all ? rootElement.all : rootElement.getElementsByTagName("*"));
	
    var attributeReg = new RegExp(value);
    var attributeValue;

    for(var i=els.length-1; i>=0; i--) {
        attributeValue = els[i].getAttribute(attributeName);
        if(attributeValue  && (!value || attributeReg.test(attributeValue))) output[output.length] = els[i];	
    }
    return output.reverse();
}


/*******
 ** vp - getParentByTagName function - (c) Indivirtual 2008 - 1.0 **	
 *******/

getParentByTagName = function(startNode, parentType) {
    if(!startNode) return null;
    var node = startNode.parentNode;
    var nodeReg = new RegExp('^'+parentType+'$', 'i');
    while(node) {
        if(nodeReg.test(node.tagName)) return node;
        node = node.parentNode;
    }
    return null;
}


/*******
 ** vp - ClassName module - (c) Indivirtual 2008 - 1.0 **	
 *******/

var ClassName = {
    add:function (node, name) {
        if (!this.contains(node, name)) node.className += ' ' + name;
    },

    remove:function (node, name) {
        if (node.className)
            node.className = node.className.replace(new RegExp('(^|\\s)'+name+'(\\s|$)','g'), ' ');
        node.className = node.className.replace(' ' + name, '');
    },

    contains:function (node, name) {
        return new RegExp('(^|\\s)'+name+'(\\s|$)').test(node.className);
    },

    swap:function (node, old, name) {
        node.className = this.contains(node, old)?
            node.className.replace(new RegExp('(^|\\s)'+old+'(\\s|$)','g'), '$1'+name+'$2') : 
            node.className.replace(new RegExp('(^|\\s)'+name+'(\\s|$)','g'), '$1'+old+'$2');
    },

    toggle:function(node, name) {
        if (!this.contains(node, name)) {
            this.add(node, name);
        }
        else {
            this.remove(node, name);
        }
    }
}



/*******
 ** vp - EventListener module - (c) Indivirtual 2008 - 1.0 **	
 *******/

var EventListener = {
    listeners:[],
    bCapture:false,
    bSafari:/safari/i.test(navigator.userAgent),
	
    addEvents:function(els, type, func, scope) {
        var events = [];
        for(var event,i=0; i<els.length; i++) {
            event = this.addEvent(els[i], type, func, scope);
            events.push(event);
        }
        return events;
    },

    addEvent:function(el, type, func, scope) {
        if(!el) return;
        var handler = this.delegate(func, scope || el);
        try {
            el.addEventListener(type, handler, this.bCapture);
        } catch (e) {
            el.attachEvent('on' + type, handler);
        }

        var event = { element:el, type:type, handler:handler, capture:this.bCapture };
        this.listeners.push(event);
        return event;
    },

    removeEvents:function(events) {
        for (var i=0; i<events.length; i++) {
            this.removeEvent(events[i]);
        }
    },

    removeEvent:function(event) {
        try {
            event.element.removeEventListener(event.type, event.handler, event.capture);
        } catch (e) {
            event.element.detachEvent('on' + event.type, event.handler);
        }

        for(var i=0; i<this.listeners.length; i++) {
            if(this.listeners[i] == event) {
                this.listeners.splice(i, 1);
                break;
            }
        }
    },

    dispatchEvents:function(elements, type) {
        for (var i=0; i<elements.length; i++) {
            this.dispatchEvent(elements[i], type);
        }
    },
	
    dispatchEvent:function(el, type) {
        var events, node = el, event = {target:el, type:type};
        while(node && !event.cancelBubble) {
            events = this.getEvents(node, type);
            for(var i=0; i<events.length; i++) {
                events[i].handler(event);
            }
            node = node.parentNode;
        }
    },

    getTarget:function(e, name) {
        var target = e.target || e.srcElement;
        var reg = name? new RegExp('^'+name+'$', 'i') : null;
        while(target && (target.nodeType != 1 || (reg && !reg.test(target.nodeName)))) {
            target = target.parentNode;
        }
        return target;
    },

    getEvents:function(el, type) {
        var result = [];
        for(var item,i=0; (item = this.listeners[i++]);) {
            if((!el || el == item.element) && (!type || type == item.type)) {
                result.push(item);
            }
        }
        return result;
    },

    cancelEvent:function(e) {
        this.preventDefault(e);
        this.stopPropagation(e);
        return false;
    },

    preventDefault:function(e) {
        try {
            e.preventDefault();
        } catch (exception) {
            e.returnValue = false;
        }

        if(this.bSafari) {
            var target = this.getTarget(e, 'a');
            if(target) { target.onclick = function() { return false; }; };
        }
    },

    stopPropagation:function(e) {
        try {
            e.stopPropagation();
        } catch (exception) {
            e.cancelBubble = true;
        }
    },
	
    setCapture:function(toggle) {
        this.bCapture = toggle;
    },

    delegate:function(func, scope) {
        return function() {
            func.apply(scope, arguments);
        }
    }
}



/*******
 ** vp - Cookie module - (c) Indivirtual 2008 - 1.0 **	
 *******/

Cookie = function (n, v, e) {
    this.name = n;
    this.value = v;
    this.expires = e;
}

Cookie.prototype.set = function () {
    var expDate = new Date();
    expDate.setTime(expDate.getTime() + (this.expires * 24 * 3600 * 1000));
    document.cookie = this.name + "=" + escape(this.value) + ((this.expires) ? "; expires=" + expDate.toUTCString() : "") + "; path=/";
} 

Cookie.prototype.get = function () {
    try {
        var reg = new RegExp(this.name+'=([^;$]+)','i');
        return decodeURI(reg.exec(document.cookie)[1]);
    } catch (e) {
        return null;
    }
}

/*******
 ** vp - parse a CSV line recusively - (c) Indivirtual 2008 - 0.1 **	
 *******/
function add(element, list) {
    list[list.length] = element
    return list
}


/* parse a CSV line in procedural style*/
function proceduralParse(line) {
    var length = line.length;
    var elements = []
    var state = 0
    var escaping = false
    var buffer = ""
    for (var i=0;i<line.length;i++) {
        var character = line.substring(i,i+1)
        if (state == 0) {
            if (character == ',') {
                elements = add(buffer, elements)
                buffer = ""
            } else if (character == '\"') {
                state = 1
            } else {
                buffer += character
            }
        } else if (state == 1) {
            if (character == '\\') {
                if (escaping) {
                    escaping = false
                    buffer += character
                } else {
                    escaping = true
                }
            } else {
                if (escaping) {
                    buffer += character
                } else {
                    if (character == '\"') {
                        state = 0
                    } else {
                        buffer += character
                    }
                }
                escaping = false
            }
        }
    }
    if (buffer != "") {
        elements = add(buffer, elements)
    }
    return elements
}