/*

Last Update: 1/2/2012
CHI-B3X

*/


var BrowserDetect = {
    init: function () {
        this.browser = this.searchString(this.dataBrowser) || "An unknown browser";
        this.version = this.searchVersion(navigator.userAgent) || this.searchVersion(navigator.appVersion) || "an unknown version";
        this.OS = this.searchString(this.dataOS) || "an unknown OS";
        var ua = navigator.userAgent;
        this.touchEnabled = function () { return !!('ontouchstart' in window); };
        this.webkit = /webkit\//i.test(ua);
        this.gecko = /gecko\//i.test(ua);
        this.trident = /trident\//i.test(ua);
        this.presto = /presto\//i.test(ua);
    },
    searchString: function (data) {
        for (var i = 0; i < data.length; i++) {
            var dataString = data[i].string;
            var dataProp = data[i].prop;
            this.versionSearchString = data[i].versionSearch || data[i].identity;
            if (dataString) {
                if (dataString.indexOf(data[i].subString) != -1) return data[i].identity;
            }
            else if (dataProp) return data[i].identity;
        }
    },
    searchVersion: function (dataString) {
        var index = dataString.indexOf(this.versionSearchString);
        if (index == -1) return;
        return parseFloat(dataString.substring(index + this.versionSearchString.length + 1));
    },
    dataBrowser: [
		{ string: navigator.userAgent, subString: "Chrome", identity: "Chrome" },
		{ string: navigator.userAgent, subString: "OmniWeb", versionSearch: "OmniWeb/", identity: "OmniWeb" },
		{ string: navigator.vendor, subString: "Apple", identity: "Safari", versionSearch: "Version" },
		{ prop: window.opera, identity: "Opera", versionSearch: "Version" },
		{ string: navigator.vendor, subString: "iCab", identity: "iCab" },
		{ string: navigator.vendor, subString: "KDE", identity: "Konqueror" },
		{ string: navigator.userAgent, subString: "Firefox", identity: "Firefox" },
		{ string: navigator.vendor, subString: "Camino", identity: "Camino" },
		{ string: navigator.userAgent, subString: "Netscape", identity: "Netscape" },
		{ string: navigator.userAgent, subString: "MSIE", identity: "Explorer", versionSearch: "MSIE" },
		{ string: navigator.userAgent, subString: "Gecko", identity: "Mozilla", versionSearch: "rv" },
		{ string: navigator.userAgent, subString: "Mozilla", identity: "Netscape", versionSearch: "Mozilla" }
	],
    dataOS: [
		{ string: navigator.platform, subString: "Win", identity: "Windows" },
		{ string: navigator.platform, subString: "Mac", identity: "Mac" },
		{ string: navigator.userAgent, subString: "iPhone", identity: "iPhone/iPod" },
		{ string: navigator.platform, subString: "Linux", identity: "Linux" }
	]

};
BrowserDetect.init();

function plugin(def, objto, objfrom) {
    try {
        var to = objto;
        var from = objfrom;
        def.name = def.name || "anonymous"; // can't be removed
        for (x in from) if (to[x]) throw def.name + "." + x + " cant't be applied " + x + " already exists.";
        to.plugin = to.plugin || {};
        def.version = def.version || 1;
        to.plugin[def.name] = def;
        for (x in from) to[x] = from[x];
    } catch (e) { alert(e); }
    return true;
}
function plugout(def, objto, objfrom) {
    try {
        var to = objto;
        var from = objfrom;
        if (!def.name) throw "anonymous plugins can't be removed";
        if (!to.plugin) throw "plugout didn't find " + def.name;
        if (!to.plugin[def.name]) throw "plugout didn't find " + def.name;
        if(BrowserDetect.browser!="Explorer") {
            for (x in objfrom)delete(objto[x]);
            delete to.plugin[def.name];
        } else {
            to[x] = null;
            to.plugin[def.name] = null;
        }
    } catch (e) {
        alert(e);
    }
    return true;
}





function vector() {
    var ret = {};
    ret.x = arguments[0];
    ret.y = arguments[1];
    ret.add = function (v) { return vector(ret.x + v.x, ret.y + v.y); };
    ret.subtract = function (v) { return vector(ret.x - v.x, ret.y - v.y); };
    ret.multiply = function (v) { return vector(ret.x * v.x, ret.y * v.y); };
    ret.divide = function (v) { return vector(ret.x / v.x, ret.y / v.y); };
    ret.dot = function (b) { var d = ret.multiply(b); return (d.x + d.y); };
    ret.magnitude = function () { var x = ret.x; var y = ret.y; return _sqrt(x * x + y * y); };
    ret.normalize = function () { var m = ret.magnitude(); return vector(ret.x / m, ret.y / m); };
    ret.transform = function (matrix) { var m = matrix.base; return vector(m[0] * ret.x + m[1] * ret.y + m[2], m[3] * ret.x + m[4] * ret.y + m[5]); };
    return ret;
}

function matrix() {
    var ret = {};
    ret.base = arguments[0] || [1, 0, 0, 0, 1, 0];
    ret.apply = function (node) {
        var array = ret.toArray(); if (BrowserDetect.gecko) { array[4] += 'px'; array[5] += 'px'; }
        var set = BrowserDetect.trident ?
                        function (node, property, value) { node.style[property] = value; } :
                    BrowserDetect.gecko ?
                        function (node, property, value) { node.style.MozTransform = value; } :
                        function (node, property, value) { node.style.setProperty(property, value); };

        set(node,
            (BrowserDetect.webkit ? '-webkit' :
                BrowserDetect.gecko ? '-moz' :
                BrowserDetect.presto ? '-o' :
                BrowserDetect.trident ? '-ms' : '') + "-transform",
            'matrix(' + array.join(',') + ')'
        );
    };
    ret._multiply = function (a1, a2, a3, a4, a5, a6, b1, b2, b3, b4, b5, b6) { return matrix([a1 * b1 + a2 * b4, a1 * b2 + a2 * b5, a1 * b3 + a2 * b6 + a3, a4 * b1 + a5 * b4, a4 * b2 + a5 * b5, a4 * b3 + a5 * b6 + a6]); };
    ret.multiply = function (b) { return ret._multiply.apply(ret, ret.base.concat(b)); };
    ret.translate = function (v) { return ret.multiply([1, 0, v.x, 0, 1, v.y]); };
    ret._angle = 0;
    ret.rotate = function (r) {
        ret._angle = r;
        var sin = Math.sin(r); var cos = Math.cos(r); return ret.multiply([cos, sin, 0, -sin, cos, 0]);
    };
    ret.scale = function (v) { return ret.multiply([v.x, 0, 0, 0, v.y, 0]); };
    ret.skew = function (v) { return ret.multiply([1, v.y || 0, 0, v.x || 0, 1, 0]); };
    ret.toArray = function () { var b = ret.base; return [b[0], b[1], b[3], b[4], b[2], b[5]]; };
    ret.parseArray = function (b) { return matrix([b[0], b[1], b[4], b[2], b[3], b[5]]); };
    return ret;
}

function dump() {
    str = [];
    for (x in arguments[0]) {
        str.push(x);
        str.push(arguments[0][x]);
    }
    return str;
}

function tracked() {
    var ret = {};
    ret.parent = arguments[0];
    ret.name = arguments[1];
    var fset = arguments[2];
    var fget = arguments[3];

    ret.onbeforeread = undefined; // ret.parent, ret.name
    ret.onafterread = undefined; // ret.panret, ret.name
    ret.onbeforechange = undefined; // ret.parent, old, new
    ret.onafterchange = undefined; // ret.parent, old, new
    ret.set = function () {
        if (fget() != arguments[0]) {
            if (ret.onbeforechange != undefined) {
                if (ret.onbeforechange(ret.parent, fget(), arguments[0])) {
                    if (ret.onafterchange != undefined) {
                        ret.onafterchange(ret.parent, arguments[0]);
                    }
                }
            } else {
                fset(arguments[0]);
                if (ret.onafterchange != undefined) {
                    ret.onafterchange(ret.parent, arguments[0]);
                }
            }
        }
    }
    ret.get = function () {
        if (ret.onbeforeread != undefined) {
            ret.onbeforeread(ret.parent, ret.name);
        }
        var res = fget();
        if (ret.onafterread != undefined) {
            ret.onafterread(ret.parent, ret.name);
        }
        return res;
    }
    return ret;
}




function alias() {

    var align = {};
    align.l = align.left = 1;
    align.t = align.top = 8;
    align.r = align.right = 4;
    align.c = align.center = 2;
    align.m = align.middle = 16;
    align.b = align.bottom = 32;
    //
    align.lt = align.tl = align.topleft = align.lefttop = 9;
    align.tr = align.rt = align.topright = align.righttop = 12;
    align.bl = align.lb = align.bottomleft = align.leftbottom = 33;
    align.br = align.rb =  align.bottomright = align.rightbottom = 36;
    align.tc = align.ct = align.topcenter = align.centertop = 10;
    align.bc = align.bc = align.bottomcenter = align.centerbottom = 34;
    align.mc = align.cm = align.middlecenter = align.centermiddle = 18;
    align.ml = align.lm = align.middleleft = align.leftmiddle = 17;
    align.mr = align.rm = align.middleright = align.rightmiddle = 20;


    var direction = {};
    direction.left = 1;
    direction.up = 2;
    direction.right = 4;
    direction.down = 8;


    var key = {};

    key.left = 37;
    key.right = 39;
    key.up = 38;
    key.down = 40;
    key.insert = 45;
    key.del = 46;
    key.home = 36;
    key.end = 35;
    key.pgup = 33;
    key.pgdown = 34;
    key.f1 = 112;
    key.f2 = 113;
    key.f3 = 114;
    key.f4 = 115;
    key.f5 = 116;
    key.f6 = 117;
    key.f7 = 118;
    key.f8 = 119;
    key.f9 = 120;
    key.f10 = 121;
    key.f11 = 122;
    key.f12 = 123;
    key.tab = 9;
    key.enter = 13;
    key.escape = 27;
    key.backspace = 8;
    key.ctrl = 0;
    key.shift = 0;
    key.alt = 0;
    key.capslock = 20;
    key.printscreen = 0;
    key.scrolllock = 0;
    key.pause = 0;
    key.space = 32;


    var color = {};
    color.red = "#f00";
    color.green = "#0f0";
    color.blue = "#00f";
    color.black = "#000";
    color.white = "#fff";

    var unit = {};
    unit.pixel = "px";

    ret= {};

    ret.color = color;
    ret.align = align;
    ret.unit = unit;
    ret.direction = direction;
    ret.key = key;

    return ret;
}


Screen = (function () {
    
    var ret = {};
    var viewportwidth;
    var viewportheight;
    ret.refresh = function () {
        if (document.all) {
            var engine = undefined;
            if (document.documentMode) engine = document.documentMode;
            else {
		engine = 5;
		if (document.compatMode) {
		    if (document.compatMode == "CSS1Compat") engine = 7;
		}
	    }
            if (engine == 5) {
                viewportwidth = screen.availWidth;
		viewportheight = screen.availHeight;
		if(BrowserDetect.version==9){
		    viewportheight -= 64;
		}
            } else {
		viewportwidth = document.documentElement.clientWidth;
		viewportheight = document.documentElement.clientHeight;
		
	    }
        } else if (typeof window.innerWidth != undefined) {
	    // Chrome, Firefox
            viewportwidth = window.innerWidth;
	    viewportheight = window.innerHeight;
        } else if (!document.documentElement && !document.documentElement.clientWidth && document.documentElement.clientWidth != 0) {
	    
            viewportwidth = document.documentElement.clientWidth; viewportheight = document.documentElement.clientHeight;
        } else {
	    
            viewportwidth = document.getElementsByTagName('body')[0].clientWidth;
            viewportheight = document.getElementsByTagName('body')[0].clientHeight;
        }
        ret.Width = viewportwidth; ret.Height = viewportheight;
    }

    ret.getpos = function(e) {
        var ret = [0, 0];
        IE = document.all ? true : false;
        if (!IE) { ret[0] = e.pageX; ret[1] = e.pageY; } else { ret[0] = window.event.clientX; ret[1] = window.event.clientY; }
        if (ret[0] < 0) { ret[0] = 0; } if (ret[1] < 0) { ret[1] = 0; }
        return ret;
    }

    ret.refresh();
    return ret;
})();


KeyMng = (function () {
    var ret = {};
    ret.shift = false; ret.ctrl = false; ret.alt = false; ret.keyCode = 0; ret.state = "";
    ret.data = [];
    ret.addstate = function (_name) { ret.data.push({ name: _name, keys: new Array() }); };
    ret.anykeydown = undefined;
    ret.anykeyup = undefined;

    ret.addkeydown = function (name, keycode, f) {
        for (var x = 0; x < ret.data.length; x++) {
            if (ret.data[x].name == name) {
                var check = false;
                for (var y = 0; y < ret.data[x].keys.length; y++) {
                    if (ret.data[x].keys[y].key == keycode) {
                        ret.data[x].keys[y].down.push(f);
                        check = true;
                    }
                }
                if (!check) { ret.data[x].keys.push({ key: keycode, down: [f], up: [], active: false }); }
                return true;
            }
        }
        return false;
    };
    ret.addkeyup = function (name, keycode, f) {
        for (var x = 0; x < ret.data.length; x++) {
            if (ret.data[x].name == name) {
                var check = false;
                for (var y = 0; y < ret.data[x].keys.length; y++) {
                    if (ret.data[x].keys[y].key == keycode) {
                        ret.data[x].keys[y].up.push(f);
                        check = true;
                    }
                }
                if (!check) { ret.data[x].keys.push({ key: keycode, down: [], up: [f], active: false }) };
                return true;
            }
        }
        return false;
    };
    ret.keydown = function (evt) {
        ret.shift = evt.shiftKey;
        ret.ctrl = evt.ctrlKey;
        ret.alt = evt.altKey;
        ret.keyCode = evt.keyCode;

        if (ret.anykeydown != undefined && ret.anykeydown != null) {
            ret.anykeydown(ret.keyCode);
        }
        for (var x = 0; x < ret.data.length; x++) {
            if (ret.data[x].name == ret.state) {
                for (var y = 0; y < ret.data[x].keys.length; y++) {
                    if (ret.data[x].keys[y].key == ret.keyCode) {
                        if (!ret.data[x].keys[y].active) {
                            ret.data[x].keys[y].active = true;
                            for (var z = 0; z < ret.data[x].keys[y].down.length; z++) {
                                try {
                                    ret.data[x].keys[y].down[z]();
                                    return false;
                                } catch (e) { }
                            }
                        } else {
                            return false;
                        }
                    }
                }
            }
        }
    };

    ret.keyup = function (evt) {
        ret.shift = evt.shiftKey;
        ret.ctrl = evt.ctrlKey;
        ret.alt = evt.altKey;
        ret.keyCode = evt.keyCode;

        //variavel.trace("U" + ret.keyCode);

        if (ret.anykeyup != undefined && ret.anykeyup != null) {
            ret.anykeyup(ret.keyCode);
        }

        for (var x = 0; x < ret.data.length; x++) {
            if (ret.data[x].name == ret.state) {
                for (var y = 0; y < ret.data[x].keys.length; y++) {
                    if (ret.data[x].keys[y].key == ret.keyCode) {
                        if (ret.data[x].keys[y].active) {
                            ret.data[x].keys[y].active = false;
                            for (var z = 0; z < ret.data[x].keys[y].down.length; z++) {
                                try {
                                    ret.data[x].keys[y].up[z]();
                                    return false;
                                } catch (e) { }
                            }
                        } else {
                            return false;
                        }
                    }
                }
            }
        }
    };
    ret.keypress = function (evt) {
        evt.returnValue = false;
        evt.cancelBubble = true;
        if (evt.stopPropagation) { evt.stopPropagation(); }
        if (evt.preventDefault) { evt.preventDefault(); }
        return true;
    }
    ret.apply = function (obj) {
        obj.onkeydown = ret.keydown;
        obj.onkeyup = ret.keyup;
        obj.onkeypress = ret.keypress;
    };
    return ret;
})();

function ScrollMng() {
    ret2 = {};
    ret2.getScrollXY = function () {
        var scrOfX = 0, scrOfY = 0;
        if (typeof (window.pageYOffset) == 'number') {
            //Netscape compliant
            scrOfY = window.pageYOffset; scrOfX = window.pageXOffset;
        } else if (document.body && (document.body.scrollLeft || document.body.scrollTop)) {
            //DOM compliant
            scrOfY = document.body.scrollTop; scrOfX = document.body.scrollLeft;
        } else if (document.documentElement && (document.documentElement.scrollLeft || document.documentElement.scrollTop)) {
            //IE6 standards compliant mode
            scrOfY = document.documentElement.scrollTop; scrOfX = document.documentElement.scrollLeft;
        }
        return [scrOfX, scrOfY];
    }

    ret2.state = -1;
    ret2.names = [];
    ret2.data = [];
    ret2.fdefault = null;
    ret2.setdefaulf = function (f) { ret2.fdefault = f; };
    ret2.add = function (state, f) { ret2.names.push(state); ret2.data.push(f); };
    ret2.set = function (state, f) { for (var x = 0; x < ret2.names.length; x++) { if (ret2.names[x] == state) { ret2.data[x] = f; return; } } ret2.add(state, f); };
    ret2.call = function (state, delta) { for (var x = 0; x < ret2.names.length; x++) { if (ret2.names[x] == state) { var f = ret2.data[x]; f(delta); return; } } };
    ret2.handle = function (delta) {
        if (ret2.state == -1) {
            var m = ret2.getScrollXY();
            if (typeof ret2.fdefault == "function") {
                ret2.fdefault(delta);
                //window.scrollBy(x, y);
            }
        } else { ret2.call(ret2.state, delta); }
    };
    ret2.wheel = function (event) {
        var delta = 0;
        if (!event) {
            /* For IE. */
            event = window.event;
        }
        if (event.wheelDelta) { /* IE/Opera. */
            delta = event.wheelDelta / 120;
            /** In Opera 9 */
            if (window.opera) delta = -delta;
        } else if (event.detail) { /** Mozilla case. */
            /** Mozilla */
            delta = -event.detail / 3;
        }
        if (delta) ret2.handle(delta);
        if (event.preventDefault) event.preventDefault();
        event.returnValue = false;
    }

    if (window.addEventListener) /** DOMMouseScroll is for mozilla. */
        window.addEventListener('DOMMouseScroll', ret2.wheel, false);
    /** IE/Opera. */
    window.onmousewheel = document.onmousewheel = ret2.wheel;
    return ret2;
}

if (!Array.prototype.map) {
    Array.prototype.map = function (fun /*, thisp*/) {
        var len = this.length;
        if (typeof fun != "function") throw new TypeError();
        var res = new Array(len);
        var thisp = arguments[1];
        for (var i = 0; i < len; i++) { if (i in this) res[i] = fun.call(thisp, this[i], i, this); }
        return res;
    };
}

//sc = ScrollMng();


plugin({ name: "alias" }, window, alias());

function factory () {
    var ret = {};
    ret._storage = [];
    ret._current = undefined;
    ret.register = function () {
        for (var x = 0; x < ret._storage.length; x++) {
            if (arguments[0].type == ret._storage[x].type)
                return false;
        }
        var newobj = {};
        newobj.type = arguments[0].type;
        newobj.dump = function () {
            var str = [];
            for (var x in this) {
                str.push(x);
                str.push(this[x]);
            }
            return str;
        }
        ret._storage.push(newobj);
        ret._current = newobj;
        if (arguments.length > 0) {
            for (var x = 0; x < arguments.length; x++) {
                ret.macro(arguments[0].type, arguments[x]);
            }
        }
        return true;
    }
    ret.clone = function (from, to) {
        if (from.type == to.type) return false;
        for (var x = 0; x < ret._storage.length; x++) {
            if (to.type == ret._storage[x].type)
                return false;
        }
        var newobj = ret.create(from);
        newobj.type = to.type;
        ret._storage.push(newobj);
        ret._current = newobj;
        return true;
    }
    ret.setk = function () { // [obj,] key, val
        if (arguments.length == 3) ret._storage[ret.get(arguments[0])[0]][arguments[1]] = arguments[2];
        else ret._current[arguments[0]] = arguments[1];
    }
    ret.getk = function () { // [obj,] key 
        return arguments.length == 2 ? ret._current[arguments[0]] : ret.get(arguments[0])[1][arguments[1]];
    }
    ret.getks = function () { // [obj]
        var i = [];
        if (arguments.length == 0) {
            for (var y in ret._current) i.push(y);
        } else {
            var def = ret.get(arguments[0]);
            for (var y in def[1]) i.push(y);
        }
        return i;
    }
    ret.getkvs = function () { // [obj]
        var def = arguments.length==0 ? ret._current : ret.get(arguments[0]);
        var i = [];
        for (var y in def[1]) { i.push(y); i.push(def[1][y]); }
        return i;
    }
    ret.macro = function () {
        for (var x in arguments[1]) ret.setk(arguments[0], x, arguments[1][x]);
    }
    ret.get = function () {
        for (var x = 0; x < ret._storage.length; x++) {
            if (ret._storage[x].type == arguments[0]) {
                return [x, ret._storage[x]];
            }
        }
        return null;
    }
    ret.create = function () {
        
        var def = ret.get(arguments[0]);
        var i = {};
        for (var y in def[1]) i[y] = def[1][y];
        return i;
    }
    
    return ret;
}

variavel = factory();
variavel.locale = (function () {
    var ret = {};
    return ret;
});


variavel.tools = {};
variavel.tools.getAttribute = function (obj, key) {
    return obj.getAttribute("key");
}
variavel.tools.setAttribute = function (obj, key, val) {
    obj.setAttribute(key, val);
}
variavel.tools.range = function (start, end) {
    var ret = [];
    for (var x = start; x <= end; x++) {
        ret.push(x);
    }
    return ret;
}
variavel.tools.bytehex = function () {
    var table = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"];
    var str = table[(arguments[0] & 0xF0) >> 4];
    str += table[(arguments[0] & 0x0F)];
    return str;
}
variavel.tools.hexbyte = function () {
    var table = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "a", "b", "c", "d", "e", "f"];
    var val = 0;
    for (var x = 0; x < 22; x++) { if (arguments[0][0] == table[x]) { if (x >= 16) { val += (x - 6) * 16; break; } else { val += x * 16; break; } } }
    for (var x = 0; x < 22; x++) { if (arguments[0][1] == table[x]) { if (x >= 16) { val += (x - 6); break; } else { val += x; break; } } }
    return val;
}
variavel.tools.rgb = function (r, g, b) { var _r = bytehex(r); var _g = bytehex(g); var _b = bytehex(b); return ["#" + _r + _g + _b, _r, _g, _b]; }
variavel.tools.rgb_invert = function (rgb) {
    // rgb = [ "#xxxxxx", xx, xx, xx];
    var _r = bytehex(255 - rgb[1]); var _g = bytehex(255 - rgb[2]); var _b = bytehex(255 - rgb[3]);
    return ["#" + _r + _g + _b, 255 - rgb[1], 255 - rgb[2], 255 - rgb[3]];
}
variavel.tools.rgb_from = function(rgb) {
    //rgb = #xxxxxx
    var r = hexbyte(rgb.charAt(1) + rgb.charAt(2)); var g = hexbyte(rgb.charAt(3) + rgb.charAt(4)); var b = hexbyte(rgb.charAt(5) + rgb.charAt(6));
    return [rgb, r, g, b];
}

variavel.tools.stringbuilder = function () {
    var ret = {};
    ret.data = [];
    ret.write = function () { ret.data.push(arguments[0]); return ret; }
    ret.print = function () { return ret.data.join(""); }
    ret.clear = function () { ret.data = []; }
    return ret;
}

variavel.tools.ajax = function() {
    var a = {};
    var method = arguments[0];
    a.assincr = true; 
    a.method = method; a.val = ""; 
    a.xmlhttp = null;
    a.url = arguments[1];
    a.type = arguments[2];
    a.callback = arguments[3] || function() { alert(arguments[0]); };
    try {
        a.xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
    } catch (e) {
        try {
            a.xmlhttp = new ActiveXObject("Msxml2.XMLHTTP");
        } catch (ex) {
            try {
                a.xmlhttp = new XMLHttpRequest();
            } catch (exc) {
                alert("ajax unavailable."); a.xmlhttp = null;
            }
        }
    }
    a.loadResult = function (url, obj,type) {
        if (a.xmlhttp) {
            a.xmlhttp.open(a.method, url, a.assincr);
            if (a.method == "GET") {
                try {
                    a.xmlhttp.send();
                } catch (err) {
                    alert(err);
                    alert("ERROR");
                }
            } else if (a.method == "POST") {
                a.xmlhttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded;");
                try { a.xmlhttp.send(url.split("?")[1]); } catch (e) { }
            }
            if (a.assincr) {
                a.xmlhttp.onreadystatechange = function () {
                    if (a.xmlhttp.readyState == 4 && (a.xmlhttp.status == 0 || a.xmlhttp.status == 200)) {
			alert(a.xmlhttp.responseText);
                        switch(a.type) {
                            case "text":obj(a.xmlhttp.responseText);break;
                            case "xml":obj(a.xmlhttp.responseXML); break;
                        }
                    }
                }
            } else { 
                switch(a.type) {
                            case "text":obj(a.xmlhttp.responseText);break;
                            case "xml":obj(a.xmlhttp.responseXML); break;
                } 
            }
        }
    }
    a.loadResult(a.url,a.callback,a.type);
    return a;
}
variavel.tools.stringfy = function() {
    var $ = function (id) { document.getElementById(id); }
    var input = document.getElementById("input1").value;
    var output = document.getElementById("output1");
    var data = [];
    data.push("\"");
    //alert(input.length);
    for (var x = 0; x < input.length; x++) {
        var c = input.charAt(x);
        if (c == '\\') {
            data.push("\\\\");
        } else if (c == '\"') {
            data.push("\\\"");
        } else if (c == '\r' || c == '\n' || c == '\t') {

        } else {
            data.push(c);
        }
    }
    data.push("\"");
    var tmp_output = data.join("");
    tmp_output = tmp_output.replace(/ +(?= )/g, '');
    output.value = tmp_output;
}
variavel.tools.falert = function () { var bargs = arguments; return function () { alert(bargs[0]); }; }
variavel.tools.getcolor = function() {
    var r = /rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/;
    if(r.test(arguments[0])) {
	return [parseInt(RegExp.$1),parseInt(RegExp.$2),parseInt(RegExp.$3)];
    }
    return "#" + arguments[0] +  "#";
}
variavel.tools.setcolor = function() {
    return "rgb(" + arguments[0][0] + ", " +arguments[0][1] + "," + arguments[0][2] +   ")";
}

variavel.tools.tableit = function () {
    var obj = arguments[0]; // array
    var cols = arguments[1]; // number of cols
    var str = [];
    str.push("<table border=1>");
    for (var x = 0; x < obj.length; x += cols) {
        str.push("<tr>");
        for (var y = 0; y < cols; y++) {
            str.push("<td>"+obj[x+y]+"</td>");
        }
        str.push("</tr>");
    }
    str.push("</table>");
    return str.join("");
}
variavel.basestyle = function () {
    var ret = {};
    ret.serialize = function () { // hex,b64,xml,json string
    }
    ret.deserialize = function () { // hex,b64,xml,json string
    }
    return ret;
}

variavel.basecontrol = function () {
    var ret = {};
    ret.use = function () {
        ret._ = arguments[0][0];
        ret.$ = arguments[0][0].style;
        ret._parent = arguments[0][1];
        return ret;
    }
    if (arguments.length >= 1) {
        if (arguments[0].length == 2) {
            ret.use([arguments[0][0], arguments[0][1]]);
        } else {
            ret.use([arguments[0]._, arguments[0]._parent]);
        }
    } else {
        ret.use([null, null]);
    }

    ret.local = [];
    ret.id = function () {
        if (arguments.length == 0) return ret._.getAttribute("id");
        ret._.setAttribute("id", arguments[0]);
        return ret;
    }
    ret.tagname = function() {
	return ret._.tagName.toLowerCase();
    }
    ret.set_ = function () { for (var x in arguments[0]) ret._[x] = arguments[0][x]; return ret; }
    ret.set$ = function () { for (var x in arguments[0]) ret.$[x] = arguments[0][x]; return ret; }
    ret.attrib = function () {
        if (arguments.length == 1) {
            return ret._.getAttribute(arguments[0]);
        } else if (arguments.length == 2) {
			if(arguments[0]=="type" && arguments[1]!="button") {
				ret._.type = arguments[1];
			} else {
				ret._.setAttribute(arguments[0], arguments[1]);
			}
        }
        return ret;
    }
    ret.parent = function () {
        if (arguments.length == 0)
            return ret._parent;
        ret._parent.removeChild(ret._);
        ret._parent = arguments[0];
        ret._parent.appendChild(ret._);
        return ret;
    }
    ret.delay = window.setTimeout;
    
    ret.timer = function () {
        var name = arguments[0];
        var act = name.substr(0, 1);
        if (act == "#" || act == ">" || act=="?" || act=="<" ) {
            name = name.substr(1, name.length - 1);
	    if(ret._.timers && act=="?") {
		return ret._.timers[name]!=undefined;
	    }
            if (ret._.timers && ret._.timers[name]) {
                switch (act) {
                    case ">": ret._.timers[name].play(); break;
                    case "<": ret._.timers[name].stop(); break;
                    case "#": ret._.timers[name].pause(); break;
                }
            }
            return ret;
        } else {
	    if(act=="!") {
		name = name.substr(1, name.length - 1);
	    }
            var frames = arguments[1];
            var tempo = arguments[2];
            var f = arguments[3];
            var load = arguments[4] || "";
	    var finish = arguments[5] || null;
            var freq = (tempo * 1000) / frames;
            ret._.timers = ret._.timers || {};
            var t = ret._.timers[name] || {};
            t.start = t.start || false;
            t.stoped = t.stoped || true;
            t.paused = t.paused || false;
            t.actions = t.actions || [];
            t.frame = t.frame || 0;
	    if(act=="!") {
		t.actions = [f];
	    } else {
		t.actions.push(f);
	    }
            if (!t.start) {
                t.pause = function () { t.paused = true; }
                t.stop = function () {
                    t.start = false;
                    t.stoped = true;
                    t.paused = false;
                    t.frame = 0;
                }
                t.play = function () {
                    var load_array = load.split(",");

                    for (var x = 0, j = load_array.length; j > 1 && x < load_array.length; x++) {
                        var kv = load_array[x].split(":");
                        ret.local[kv[0]] = ret[kv[1]]();
                    }
                    if (!t.paused) t.stop();
                    t.paused = false;
                    t.stoped = false;
                    t.start = true;
		    
                    t.handle = window.setInterval(function () {
                        if (!t.paused) {
			    var cancelframe = false;
                            for (var x = 0; x < t.actions.length; x++) {
                                if(!t.actions[x](ret, t.frame, ret.local)) {
				    
				    cancelframe = true;
				    break;
				}
				//alert(t.actions.length);
                            }
			    if(!cancelframe) t.frame += 1;
                            if (t.frame == frames) t.stop();
                        }
                    }, freq);
                    t.stop = function () {
                        window.clearInterval(t.handle);
			if(finish!=null) finish();
                        t.start = false;
                        t.stoped = true;
                        t.paused = false;
                        t.frame = 0;
                    }
                }
                t.play();
            }
            ret._.timers[name] = t;
        }
    }
    ret.kill = function () { ret.parent().removeChild(ret._); }
    ret.add = function () {
        for (var x = 0; x < arguments.length; x++) {
            ret._.appendChild(arguments[x]._);
        }
    }
    ret.rm = function () {
        for (var x = 0; x < arguments.length; x++) ret._.removeChild(arguments[x]._);
    }
    return ret;
}
variavel.bodycontrol = function () {
    var ret = variavel.basecontrol([arguments[0][0], arguments[0][1]]);
    
    ret.copystylefrom = function() {
	for(var x = 1; x < arguments.length;x++) ret.$[ arguments[x] ] = arguments[0].$[ arguments[x] ];
	return ret;
    }
    
    ret.topradius = function () {
        ret.$["border-top-left-radius"] = arguments[0] + "px";
        ret.$["border-top-right-radius"] = arguments[0] + "px";
        return ret;
    }
    ret.bottomradius = function () {
        ret.$["border-bottom-left-radius"] = arguments[0] + "px";
        ret.$["border-bottom-right-radius"] = arguments[0] + "px";
        return ret;
    }
    ret.leftradius = function () {
        ret.$["border-top-left-radius"] = arguments[0] + "px";
        ret.$["border-bottom-left-radius"] = arguments[0] + "px";
        return ret;
    }
    ret.rightradius = function () {
        ret.$["border-top-right-radius"] = arguments[0] + "px";
        ret.$["border-bottom-right-radius"] = arguments[0] + "px";
        return ret;
    }
    ret.css = function () {
        if (arguments.length == 0) return variavel.tools.getAttribute(ret._, "style");
        variavel.tools.setAttribute(ret._, "style", arguments[0]);
        return ret;
    }
    ret.cssattrib = function() {
	variavel.tools.setAttribute(ret.$,arguments[0],arguments[1]);
	return ret;
    }
    ret.bg = function () {
        if (arguments.length == 0) return ret.$.backgroundColor || "#fff";
        ret.$.backgroundColor = arguments[0];
        return ret;
    }
    ret.alpha = function () {
        if (arguments.length == 0) return ret.$.opacity || 1;
        ret.$.opacity = arguments[0];
        return ret;
    }
    ret.fg = function () {
        if (arguments.length == 0) return ret.$.color || "#000";
        ret.$.color = arguments[0];
        return ret;
    }
    ret.border = function () {
        if (arguments.length == 0) ret.$.border = "solid 1px #000";
        else ret.$.border = arguments[0];
        return ret;
    }

    

    ret.abs = function () {
        if (arguments.length == 1) ret.bounds(arguments[0]);
        else if (arguments.length == 4) ret.bounds(arguments[0], arguments[1], arguments[2], arguments[3]);
        ret.$.position = "absolute";
        return ret;
    }
    ret.fix = function () {
        if (arguments.length == 1) ret.bounds(arguments[0]);
        else if (arguments.length == 4) ret.bounds(arguments[0], arguments[1], arguments[2], arguments[3]);
        ret.$.position = "fixed"; return ret;
    }
    ret.hide = function () { ret.$.display = "none"; return ret; }
    ret.show = function () { ret.$.display = "inline"; return ret; }
    ret._._rotate = 0;
    ret.rotate = function () {
        ret._._rotate = arguments[0];
        matrix().rotate(ret._._rotate).apply(ret._);
        return ret;
    }
    var a0 = ["click", "onclick", "mover", "onmouseover", "mout", "onmouseout",
                "mup", "onmouseup", "mdown", "onmousedown", "mmove", "onmousemove", "kdown", "onkeydown", "kup", "onkeyup",
                "kpress", "onkeypress", "text", "innerHTML"];
    for (var x = 0; x < a0.length; x += 2) {
        (function (z) {
            ret[a0[z]] = function () {
                if (arguments.length == 0) return ret._[a0[z + 1]];
                ret._[a0[z + 1]] = arguments[0];
                return ret;
            }
        })(x);
    }
    
    ret.appendtext = function() {
	return ret.text(ret.text()+arguments[0]);
    }
    ret.radius = function () {
        ret.$["border-radius"] = arguments[0] + "px";
        return ret;
    }
    ret.abs = function () {
        if (arguments.length == 1) ret.bounds(arguments[0]);
        else if (arguments.length == 4) ret.bounds(arguments[0], arguments[1], arguments[2], arguments[3]);
        ret.$.position = "absolute";
        return ret;
    }
    ret.fix = function () {
        if (arguments.length == 1) ret.bounds(arguments[0]);
        else if (arguments.length == 4) ret.bounds(arguments[0], arguments[1], arguments[2], arguments[3]);
        ret.$.position = "fixed"; return ret;
    }
    ret.hide = function () { ret.$.display = "none"; return ret; }
    ret.show = function () { ret.$.display = "inline"; return ret; }

    ret._._rotate = 0;
    ret.rotate = function () {
        ret._._rotate = arguments[0];
        matrix().rotate(ret._._rotate).apply(ret._);
        return ret;
    }

    var a0 = ["click", "onclick", "mover", "onmouseover", "mout", "onmouseout",
                "mup", "onmouseup", "mdown", "onmousedown", "mmove", "onmousemove", "kdown", "onkeydown", "kup", "onkeyup",
                "kpress", "onkeypress", "text", "innerHTML","client_width","clientWidth"];
    for (var x = 0; x < a0.length; x += 2) {
        (function (z) {
            ret[a0[z]] = function () {
                if (arguments.length == 0) return ret._[a0[z + 1]];
                ret._[a0[z + 1]] = arguments[0];
                return ret;
            }
        })(x);
    }
    ret._autoclip = false;
    ret.autoclip = function () {
        if (arguments.length == 0) return ret._autoclip;
        if (arguments[0]) {
	    var dx = arguments[1] || 0;
	    var dy = arguments[2] || 0;
            ret._autoclip = true;
            var s = ret.sz();
            var str = "rect(0px " + (s[0]+dx) + "px " + (s[1]+dy) + "px 0px)";
            ret.$.clip = str;

        } else {
            ret._autoclip = false;
            ret.$.clip = "";
        }
        return ret;
    };

    var a1 = ["index", "zIndex","overflow","overflow","overflow_y","overflowY","overflow_x","overflowX",
	      "font","font","font_family","fontFamily",
	      "text_align","textAlign",
	      "cursor","cursor",
	      "border_left","borderLeft","border_right","borderRight","border_top","borderTop","border_bottom","borderBottom",
	      "border_left_width","borderLeftWidth","border_right_width","borderRightWidth","border_top_width","borderTopWidth","border_bottom_width","borderBottomWidth",
	      "border_left_color","borderLeftColor","border_right_color","borderRightColor","border_top_color","borderTopColor","border_bottom_color","borderBottomColor",
	      "border_left_style","borderLeftStyle","border_right_style","borderRightStyle","border_top_style","borderTopStyle","border_bottom_style","borderBottomStyle"
	      
    ];
    for (var x = 0; x < a1.length; x += 2) {
        (function (z) {
            ret[a1[z]] = function () {
                if (arguments.length == 0) return ret.$[a1[z + 1]];
                ret.$[a1[z + 1]] = arguments[0];
                return ret;
            }
        })(x);
    }

    var a3 = ["margin", "margin", "padding", "padding","font_size","fontSize",
	      "padding_left","paddingLeft","padding_right","paddingRight","padding_top","paddingTop","padding_bottom","paddingBottom",
	      "margin_left","marginLeft","margin_right","marginRight","margin_top","marginTop","margin_bottom","marginBottom"];
    for (var x = 0; x < a3.length; x += 2) {
        (function (z) {
            ret[a3[z]] = function () {
                if (arguments.length == 0) return ret.$[a3[z + 1]];
                ret.$[a3[z + 1]] = arguments[0] + "px";
                return ret;
            }
        })(x);
    }

    ret.addoption = function() {
	var theSelectList = ret._;
	var text = arguments[0] || "";
	var value = arguments[1] || "0";
	var sel = arguments[2] || false;
	if(BrowserDetect.browser=="Explorer") {
	    if (ret._.options != null) {
	        ret._.options[ret._.options.length] = new Option(text, value, false, sel);
	    }
	} else {
	    ret._.add( $("!option").attrib("value",value).text(text)._ , null);
	}
    }

    ret.draggable = function () {
        var applyto = arguments[0] || ret;
        ret.mover(function () {
            ret.$.cursor = "move";
        });
        ret.mdown(function (e) {
            window.onmousedown = function () { return false; } // mozilla
            window.onselectstart = function () { return false; } // ie

            var p = Screen.getpos(e);
            ret._.startpos_mouse = p;
            ret._.startpos_target = applyto.pos();
            ret.$.cursor = "move";
            ret.mmove(window.onmousemove = function (e1) {
                var p2 = Screen.getpos(e1);
                var p3 = ret._.startpos_target;
                var p4 = [p3[0] + p2[0] - p[0], p3[1] + p2[1] - p[1]];
                ret.$.cursor = "move";
                applyto.pos(p4);
            });
            ret.mup(window.onmouseup = function () {
                window.onselectstart = null;
                window.onmousemove = null;
                window.onmousedown = null;
                ret.$.cursor = "default";
                ret.mmove(null);
                ret.mup(null);
            });
        });
    }
    
    ret.scrolly = function() { var b = arguments[0] || true; if(b) ret.$.overflowY = "scroll"; else ret.$.overflowY = "auto"; return ret; }
    ret.scrollx = function() { var b = arguments[0] || true; if(b) ret.$.overflowX = "scroll"; else ret.$.overflowX = "auto"; return ret; }
    ret.scroll = function() { var b = arguments[0] || true; if(b) ret.$.overflow= "scroll"; else ret.$.overflow = "auto"; return ret; }
    
    ret.align2s = function () {
        Screen.refresh();
        var p = [0, 0];
        p[0] = (arguments[0] & align.left) > 0 ? 0 : ret.pos()[0];
        p[0] = (arguments[0] & align.center) > 0 ? (Screen.Width - ret.sz()[0]) / 2 : p[0];
        p[0] = (arguments[0] & align.right) > 0 ? (Screen.Width - ret.sz()[0]) : p[0];
        p[1] = (arguments[0] & align.top) > 0 ? 0 : ret.pos()[1];
        p[1] = (arguments[0] & align.middle) > 0 ? (Screen.Height - ret.sz()[1]) / 2 : p[1];
        p[1] = (arguments[0] & align.bottom) > 0 ? (Screen.Height - ret.sz()[1]) : p[1];
        return p;
    }
    ret.falign2s = function () {
        var offsetx = arguments[1] || 0;
        var offsety = arguments[2] || 0;
        var p = ret.align2s(arguments[0]);
        ret.pos(p[0] + offsetx, p[1] + offsety);
        return ret;
    }
    ret.align2o = function () {
        var o = arguments[0]; // obj
        var a1 = arguments[1]; // [ x ,y ] of invisible matrix
        var a2 = arguments[2]; // align to point
        var s1 = ret.sz();
        var p2 = o.abspos();
        var s2 = o.sz();
        var m = arguments.length == 4 ? arguments[4] : { type: "iso", data: [3, 3] }; // matrix of align, or matrix of pos,size
        if (m.type == "iso") {
            var dx = s2[0] / (m.data[0] - 1);
            var dy = s2[1] / (m.data[1] - 1);
            if ((a2 & align.t) > 0) {
                if ((a2 & align.l) > 0) {
                    return [p2[0] + dx * a1[0] - s1[0], p2[1] + dy * a1[1] - s1[1]];
                } else if ((a2 & align.c) > 0) {
                    return [p2[0] + dx * a1[0] - s1[0] / 2, p2[1] + dy * a1[1] - s1[1]];
                } else if ((a2 & align.r) > 0) {
                    return [p2[0] + dx * a1[0], p2[1] + dy * a1[1] - s1[1]];
                }
            } else if ((a2 & align.m) > 0) {
                if ((a2 & align.l) > 0) {
                    return [p2[0] + dx * a1[0] - s1[0], p2[1] + dy * a1[1] - s1[1] / 2];
                } else if ((a2 & align.c) > 0) {
                    return [p2[0] + dx * a1[0] - s1[0] / 2, p2[1] + dy * a1[1] - s1[1] / 2];
                } else if ((a2 & align.r) > 0) {
                    return [p2[0] + dx * a1[0], p2[1] + dy * a1[1] - s1[1] / 2];
                }
            } else if ((a2 & align.b) > 0) {
                if ((a2 & align.l) > 0) {
                    return [p2[0] + dx * a1[0] - s1[0], p2[1] + dy * a1[1]];
                } else if ((a2 & align.c) > 0) {
                    return [p2[0] + dx * a1[0] - s1[0] / 2, p2[1] + dy * a1[1]];
                } else if ((a2 & align.r) > 0) {
                    return [p2[0] + dx * a1[0], p2[1] + dy * a1[1]];
                }
            }

        }
        return [p1[0], p1[1]];
    }

    ret.hasclass = function () {
        return ret._.className.match(new RegExp('(\\s|^)' + arguments[0] + '(\\s|$)'));
    }
    ret.addclass = function () {
        if (!ret.hasclass(arguments[0])) ret._.className += " " + arguments[0];
    }
    ret.rmclass = function () {
        if (ret.hasclass(arguments[0])) {
            ret._.className = ret._.className.replace(new RegExp('(\\s|^)' + cls + '(\\s|$)'), "");
        }
    }
    ret.toogleclass = function () {
        if (ret.hasclass(arguments[0])) ret.rmclass(arguments[0]);
        else ret.addclass(arguments[0]);
    }
    ret.replaceclass = function () {
        if (ret.hasclass(arguments[0]) && !ret.hasclass(arguments[1])) {
            ret.rmclass(arguments[0]);
            ret.addclass(arguments[1]);
        }
    }

    ret.sz = function () {
        if (arguments.length == 0) return [ret._._w, ret._._h];
        if (arguments.length == 1) {
            if (ret._.svg) {
                ret._.width = arguments[0][0].toString();
                ret._.height = arguments[0][1].toString();
            } else {
                ret.$.width = arguments[0][0] + "px";
                ret.$.height = arguments[0][1] + "px";
            }
            ret._._w = arguments[0][0];
            ret._._h = arguments[0][1];
        } else {
            if (ret._.svg) {
                ret._.setAttribute("width", arguments[0].toString());
                ret._.setAttribute("height", arguments[1].toString());
            } else {
                ret.$.width = arguments[0] + "px";
                ret.$.height = arguments[1] + "px";
		var v = arguments[2] || null;
		if(v!=null) {
		    
		}
            }
            ret._._w = arguments[0];
            ret._._h = arguments[1];
        }
        return ret;
    }

    ret.pos = function () {
		if (arguments.length == 0) return [ret._._x, ret._._y];
		if (arguments.length == 1) {
			if (ret._.svg) {
				ret._.setAttribute("x", arguments[0][0] + "px");
				ret._.setAttribute("y", arguments[0][1] + "px");
			} else {
				ret.$.left = arguments[0][0] + "px";
				ret.$.top = arguments[0][1] + "px";
			}
			ret._._x = arguments[0][0];
			ret._._y = arguments[0][1];
		} else {
			if (ret._.svg) {
				ret._.setAttribute("x", arguments[0].toString() + "px");
				ret._.setAttribute("y", arguments[1].toString() + "px");
			} else {
				if (BrowserDetect.browser == "Explorer") {
					ret.$.left = arguments[0];
					ret.$.top = arguments[1];
				} else {
					ret.$.left = arguments[0] + "px";
					ret.$.top = arguments[1] + "px";
				}
			}
			ret._._x = arguments[0];
			ret._._y = arguments[1];
		}
		return ret;
	}
    ret.abspos = function () {
        if (arguments.length == 0) {
            var x = 0;
            var y = 0;
            var cur = ret._;
            var b = document.getElementsByTagName("body")[0];
            do {
                x += parseInt(cur.style.left);
                y += parseInt(cur.style.top);
                cur = cur.parentNode;
            } while (cur != b);
            return [x, y];
        } else {
            var p0 = ret.abspos();
            var p1 = ret.pos();
            var px = p0[0] - p1[0];
            var py = p0[1] - p1[1];
            if (arguments.length == 1) {
                ret.pos(arguments[0][0] - px, arguments[0][1] - py);
            } else {
                ret.pos(arguments[0] - px, arguments[1] - py);
            }

        }
        return ret;
    }
    ret.bounds = function () {
        if (arguments.length == 0) return [parseInt(ret.$.left), parseInt(ret.$.top), parseInt(ret.$.width), parseInt(ret.$.height)];
        if (arguments.length == 1) {
            ret.pos(arguments[0][0], arguments[0][1]);
            ret.sz(arguments[0][2], arguments[0][3]);
        } else {
            ret.pos(arguments[0], arguments[1]);
            ret.sz(arguments[2], arguments[3]);
        }
        return ret;
    }
    ret.gradient = function() {
	var a = arguments;
	if(BrowserDetect.browser=="Explorer") {
	    ret.$.filter = "progid:DXImageTransform.Microsoft.gradient(startColorstr='"+a[0]+"', endColorstr='"+a[1]+"')";
	} else if(BrowserDetect.browser=="Firefox") {
	    ret.$.background = "-moz-linear-gradient(top,"+a[0]+","+a[1]+")";
	} else {
	    ret.$.background = "-webkit-gradient(linear, left top, left bottom, from("+a[0]+"), to("+a[1]+"))";
	}
	return ret;
	
    }
    ret.posoffsetx = function () {
        var p = ret.pos();
        ret.pos(p[0] + arguments[0], p[1]);
        return ret;
    }
    ret.posoffsety = function () {
        var p = ret.pos();
        ret.pos(p[0], p[1] + arguments[0]);
        return ret;
    }
    ret.szoffsetw = function () {
        var s = ret.sz();
        ret.sz(s[0] + arguments[0], s[1]);
        return ret;
    }
    ret.szoffseth = function () {
        var s = ret.sz();
        ret.sz(s[0], s[1] + arguments[0]);
        return ret;
    }
    return ret;
}
variavel.svgcontrol = function () {
    var ret = variavel.bodycontrol([arguments[0][0], arguments[0][1]]);

    if (!ret._.defs) {
        if (ret._.svg && ret._.svgmaster) {
            ret._.defs = $(ret, "!defs:" + ret.id() + "_defs");
        } else if (ret._.svg) {
            ret._.defs = ret._.svgdoc.defs;
        }
    }

    var a1 = ["fill", "fill", "stroke", "stroke", "stroke_width", "strokeWidth"];
    for (var x = 0; x < a1.length; x += 2) {
        (function (z) {
            ret[a1[z]] = function () {
                if (arguments.length == 0) return ret.$[a1[z + 1]];
                ret.$[a1[z + 1]] = arguments[0];
                return ret;
            }
        })(x);
    }

    ret.line = function () {
        if (!ret._.svg) return null;
        var r = undefined;
        if (typeof arguments[0] == "string") {
            var r = $(ret, "!line:" + arguments[0]).x1(arguments[1]).y1(arguments[2]).x2(arguments[3]).y2(arguments[4]);
            r._.svgdoc = ret;
        } else {
            r = $(ret, "!line").x1(arguments[0]).y1(arguments[1]).x2(arguments[2]).y2(arguments[3]);
            r._.svgdoc = ret;
        }
        return r;
    }
    ret.ellipse = function () {
        if (!ret._.svg) return null;
        var r = undefined;
        if (typeof arguments[0] == "string") {
            r = $(ret, "!ellipse:" + arguments[0]).cx(arguments[1]).cy(arguments[2]).rx(arguments[3]).ry(arguments[4]);
            r._.svgdoc = ret;
        } else {
            r = $(ret, "!ellipse").cx(arguments[0]).cy(arguments[1]).rx(arguments[2]).ry(arguments[3]);
            r._.svgdoc = ret;
        }
        return r;
    }
    ret.rect = function () {
        var a = arguments;
        if (!ret._.svg) return null;
        var r = undefined;
        if (typeof arguments[0] == "string") {
            r = $(ret, "!rect:" + a[0]).bounds(a[1], a[2], a[3], a[4]);
            r._.svgdoc = ret;
        } else {
            r = $(ret, "!rect").bounds(a[0], a[1], a[2], a[3]);
            r._.svgdoc = ret;
        }
        return r;
    }
    ret.polygon = function () {
        if (!ret._.svg) return null;
        var r = undefined;
        if (typeof arguments[0] == "string") {
            r = $(ret, "!polygon:" + arguments[0]).points(arguments[1]);
            r._.svgdoc = ret;
        } else {
            r = $(ret, "!polygon").points(arguments[0]);
            r._.svgdoc = ret;
        }
        return r;
    }
    ret.polyline = function () {
        if (!ret._.svg) return null;
        var r = undefined;
        if (typeof arguments[0] == "string") {
            r = $(ret, "!polyline:" + arguments[0]).points(arguments[1]);
            r._.svgdoc = ret;
        } else {
            r = $(ret, "!polyline").points(arguments[0]);
            r._.svgdoc = ret;
        }
        return ret;
    }
    ret.path = function () {
        if (!ret._.svg) return null;
        var obj = null;

        if (typeof arguments[0] == "string") {
            obj = $(ret, "!path:" + arguments[0]);
	    ret._.svgscale = arguments[1] || 1;
        } else {
	    ret._.svgscale = arguments[0] || 1;
	    obj = $(ret, "!path");
        }
	
        var path = obj;
	ret._.svgtranslate = [0,0];
	path.translate = function() {
	    ret._.svgtransle = [arguments[0],arguments[1]];
	    return path;
	}
	function transform1() { return [ arguments[0]*ret._.svgscale]; }
	function transform2() { return [ arguments[0]*ret._.svgscale, arguments[1]*ret._.svgscale ]; }
	function transform3() { return [ arguments[0]*ret._.svgscale, arguments[1]*ret._.svgscale, arguments[2]*ret._.svgscale ]; }
	function transform4() { return [ arguments[0]*ret._.svgscale, arguments[1]*ret._.svgscale, arguments[2]*ret._.svgscale, arguments[3]*ret._.svgscale ]; }
	function transform5() { return [ arguments[0]*ret._.svgscale, arguments[1]*ret._.svgscale, arguments[2]*ret._.svgscale, arguments[3]*ret._.svgscale, arguments[4]*ret._.svgscale ]; }
	function transform6() { return [ arguments[0]*ret._.svgscale, arguments[1]*ret._.svgscale, arguments[2]*ret._.svgscale, arguments[3]*ret._.svgscale, arguments[4]*ret._.svgscale, arguments[5]*ret._.svgscale ]; }
	function transform7() { return [ arguments[0]*ret._.svgscale, arguments[1]*ret._.svgscale, arguments[2]*ret._.svgscale, arguments[3]*ret._.svgscale, arguments[4]*ret._.svgscale, arguments[5]*ret._.svgscale, arguments[6]*ret._.svgscale ]; }
	
        path.__d = [];
        path.move = function () { var a = arguments; a = transform2(a[0],a[1]); path.__d.push("M" + a[0] + " " + a[1]); return path; }
        path.line = function () {
	    var a = arguments;
	    a = transform2(a[0],a[1]);
	    path.__d.push("L" + a[0] + " " + a[1]);
	    return path;
	}
        path.horizontal = function () { var a = arguments; a = transform1(a[0]); path.__d.push("H" + a[0]); return path; }
        path.vertical = function () { var a = arguments; a = transform1(a[0]); path.__d.push("V" + a[0]); return path; }
        path.bezier = function () { var a = arguments; a = transform1(a[0]); path.__d.push("C" + a[0] + "," + a[1] + " " + a[2] + "," + a[3] + " " + a[4] + "," + a[5]); return path; }
        path.bezierr = function () { var a = arguments; a = transform6(a[0],a[1],a[2],a[3],a[4],a[5]); path.__d.push("c" + a[0] + " " + a[1] + " " + a[2] + " " + a[3] + " " + a[4] + " " + a[5]); return path; }
        path.sbezier = function () { var a = arguments; a = transform4(a[0],a[1],a[2],a[3]); path.__d.push("S" + a[0] + " " + a[1] + " " + a[2] + " " + a[3]); return path; }
        path.sbezierr = function () { var a = arguments; a = transform4(a[0],a[1],a[2],a[3]); path.__d.push("s" + a[0] + " " + a[1] + " " + a[2] + " " + a[3]); return path; }
        path.qbezier = function () { var a = arguments; a = transform4(a[0],a[1],a[2],a[3]); path.__d.push("Q" + a[0] + " " + a[1] + " " + a[2] + " " + a[3]); return path; }
        path.qbezierr = function () { var a = arguments; a = transform4(a[0],a[1],a[2],a[3]); path.__d.push("q" + a[0] + " " + a[1] + " " + a[2] + " " + a[3]); return path; }
        path.sqbezier = function () { var a = arguments; a = transform2(a[0],a[1]); path.__d.push("T" + a[0] + " " + a[1]); return path; }
        path.sqbezierr = function () { var a = arguments; a = transform2(a[0],a[1]); path.__d.push("t" + a[0] + " " + a[1]); return path; }
        path.arc = function () { var a = arguments; a = transform7(a[0],a[1],a[2],a[3],a[4],a[5],a[6]); path.__d.push("A" + a[0] + " " + a[1] + " " + a[2] + " " + a[3] + " " + a[4] + " " + a[5] + " " + a[6]); return path; }
        path.arcrel = function () { var a = arguments; a = transform7(a[0],a[1],a[2],a[3],a[4],a[5],a[6]); path.__d.push("a" + a[0] + " " + a[1] + " " + a[2] + " " + a[3] + " " + a[4] + " " + a[5] + " " + a[6]); return path; }
        path.draw = function () {
            path.__d.push("Z");
            var data = path.__d.join("");
            path.attrib("d", data);
            return path;
        }
        path._.svgdoc = ret;
        return path;

    }
    ret.lineargradient = function () {
        if (ret._.svg) {
            var lg = $(ret._.defs, "!linearGradient:" + arguments[0]).attrib("x1", arguments[1] + "%").attrib("y1", arguments[2] + "%").attrib("x2", arguments[3] + "%").attrib("y2", arguments[4] + "%");
            $(lg, "!stop").attrib("stop-color", arguments[5]).attrib("offset", "0");
            $(lg, "!stop").attrib("stop-color", arguments[6]).attrib("offset", "100%");
            ret.fill("url(#" + arguments[0] + ")");
            return ret;
        } else {

        }
    }
    ret.radialgradient = function () {
        if (ret._.svg) {
            var rg = $(ret._.defs, "!radialGradient:" + arguments[0]).attrib("cx", arguments[1] + "%").attrib("cy", arguments[2] + "%").attrib("r", arguments[3] + "%").attrib("fx", arguments[4] + "%").attrib("fy", arguments[5] + "%");
            $(rg, "!stop").attrib("stop-color", arguments[6]).attrib("offset", "0");
            $(rg, "!stop").attrib("stop-color", arguments[7]).attrib("offset", "100%");
            ret.fill("url(#" + arguments[0] + ")");
            return ret;
        } else {
        }
    }
    ret.filter = function () {
        if (ret._.svg) {
            var r = $(ret._.defs, "!filter:" + arguments[0]).x(arguments[1]).y(arguments[2]);
            r.blur = function () {
                $(r, "!feGaussianBlur").attrib("in", arguments[0]).attrib("stdDeviation", arguments[1]);
                ret.attrib("filter", "url(#" + arguments[0] + ")");
                return r;
            };
            r.parent = ret;
            return r;
        }
    }
    ret.radius = function () {
        if (ret._.svg) {
            ret.rx(arguments[0]);
            ret.ry(arguments[0]);
        } else {
            ret.$["border-radius"] = arguments[0] + "px";
        }
        return ret;
    }
    var svg_attribs = ["x1", "y1", "x2", "y2", "cx", "cy", "rx", "ry", "x", "y", "width", "height"];
    for (var x = 0; x < svg_attribs.length; x++) {
        (function (z) {
            ret[svg_attribs[z]] = function () {
                if (arguments.length == 0) return ret._.getAttribute(svg_attribs[z]);
                ret._.setAttribute(svg_attribs[z], arguments[0] + "px");
                return ret;
            }
        })(x);
    }

    ret.points = function () {
        if (arguments.length == 0) return ret._.getAttribute("points");
        ret._.setAttribute("points", arguments[0]);
        return ret;
    }
    return ret;
}

variavel.basecontrol_todo = function () {
    ret.resizeable = function () {
    }
    ret.rotateable = function () {
    }
    ret.selectable = function () {
    }
    return ret;
}

variavel.spritemanager = function () {
    var ret = {};
    ret.images = {};
    ret.addimage = function () {
        var im = {};
        im.sprites = {};
        im.path = arguments[0];
        im.addsprite = function() {
            var sp = {};
            sp.x = arguments[1];
            sp.y = arguments[2];
            im.sprites[arguments[0]] = sp;
        }
        ret.images[arguments[0]] = im;
    }
    ret.load = function() {
        var a = arguments;
        return "background:url('"+ret.images[a[0]].path+"') -"+ret.images[a[0]].sprites[a[1]].x+"px -"+ret.images[a[0]].sprites[a[1]].x+"px;";
    }
    ret.apply = function() {
        var a = arguments;
        a[0].attrib("background","url('"+ret.images[a[1]].path+"') -"+ret.images[a[1]].sprites[a[2]].x+"px -"+ret.images[a[1]].sprites[a[2]].x+"px;");
    }
    return ret;
}

variavel.cur_bodycontrol = variavel.bodycontrol;

variavel.el = function () {

	var svg_tags = ["svg", "line", "rect", "ellipse", "polygon", "polyline", "path", "text", "defs", "linearGradient", "radialGradient", "stop", "feGaussianBlur", "filter"];
	var svgns = "http://www.w3.org/2000/svg";
	var xlinkns = "http://www.w3.org/1999/xlink";

	var asel = typeof arguments[0] == "string" ? arguments[0] : arguments[1];
	var e = undefined;
	var sel = asel.substr(0, 1);
	var fname = asel.substr(1, asel.length - 1);
	var tuple = fname.split(":");
	var type = "head";
	var argsbase = arguments;
	var b = (function () {
		var head_tags = ["script", "style", "link", "meta"];
		var c = false;
		for (var x = 0; x < head_tags.length; x++) {
			if (tuple[0] == head_tags[x]) {
				c = true;
				break;
			}
		}
		if (typeof argsbase[0] == "string") {
			if (!c) {
				type = "body";


				return document.getElementsByTagName("body")[0];
			}
			return document.getElementsByTagName("head")[0];
		} else {
			if (c) {
				type = "head";
			} else {
				type = "body";
			}
			return argsbase[0]._;
		}
	})();

	var et = "";
	var check = false;
	var ndap = true;

	switch (sel) {
		case "!":
			for (var x = 0; x < svg_tags.length; x++) {
				if (tuple[0] == svg_tags[x]) {
					check = true; break;
				}
			}
			if (check) {
				e = document.createElementNS(svgns, "svg:" + tuple[0]);
				if (tuple[0] == "svg") {
					e.svgmaster = true;
					//e.setAttributeNS("xmlns", "xlink", xlinkns);
				} else {
					e.svgdoc = b;
					e.svgmaster = false;
				}
				e.svg = true;
			} else {
				try {
					e = document.createElement(tuple[0]);
				} catch (e) {
					alert(tuple[0]);
				}
				e.svg = false;
			}
			e.__tag = tuple[0];
			break;
		case "#":
			e = document.getElementById(tuple[0]);
			if (e == null) {
				alert(tuple[0]);
				throw new Exception();
			}
			b = e.parentNode;
			ndap = false;
			break;
		default:
			e = document.getElementById(tuple.length == 2 ? tuple[1] : tuple[0]);
			if (!e) {
				for (var x = 0; x < svg_tags.length; x++) {
					if (tuple[0] == svg_tags[x]) {
						check = true; break;
					}
				}
				if (check) {
					e = document.createElementNS(svgns, "svg:" + tuple[0]);
					if (tuple[0] == "svg") {
						e.svgmaster = true;
						e.setAttributeNS("xmlns", svgns);
						//e.setAttributeNS("xmlns", "xlink", xlinkns);
					} else {
						e.svgdoc = b;
						e.svgmaster = false;
					}

					e.svg = true;
				} else {
					e = document.createElement(tuple[0]);
					e.svg = false;
				}
				e.__tag = tuple[0];
			}
			break;
	}
	e._type = type;
	if (tuple.length == 2) {
		var s = tuple[1].split(",");
		if (s.length >= 1) {
			variavel.tools.setAttribute(e, "id", s[0]);
			if (s.length >= 2) {
				for (var x = 1; x < s.length; x++) {
					var s0 = s[x].split("=");
					variavel.tools.setAttribute(e, s0[0], s0[1]);
				}
			}
		}
	}
	if (ndap) {

		b.appendChild(e);
	}
	//alert(e.tagName);
	if (e.svg) {
		return variavel.svgcontrol([e, b]);
	} else {
		switch (e._type) {
			case "body":
				//alert("OK");
				return variavel.cur_bodycontrol([e, b]);
			default:
				//alert(tuple[0]);
				return variavel.basecontrol([e, b]);
		}
	}
}


$ = variavel.el;
sb = variavel.tools.stringbuilder();
debug = function (obj) {
    return variavel.tools.tableit(dump(obj), 2);
}


variavel.tools.loadpacket = function () {
    var bargs = arguments;
    variavel.tools.ajax("GET", bargs[0], "text", function () {
        var script = $("!script:" + bargs[0]).attrib("type", "text/javascript");
        script._.defer = true;
        script._.innerHTML = arguments[0];
        var start = bargs[1] || function () { main(); }
        start();
        //script.kill();
    });
}

variavel.tools.hash = function () {
    var ret = {};
    ret.refresh = function () {
        ret.location = window.location.toString();
        ret.parts = ret.location.split("#");
        ret.base = ret.parts[0];
    }
    ret.get = function () {
        ret.refresh();
        if (ret.parts.length > 1) {
            return ret.parts[ret.parts.length - 1];
        }
        return "";
    }
    ret.set = function () {
        ret.refresh();
        window.location = ret.base + "#" + arguments[0];
    }
    ret.refresh();
    return ret;
}
variavel.tools.svg = function () {
    var ret = {};
    ret.line = function () {
        var bargs = arguments;
        var a = bargs;
        var l = a[1] < a[3] ? a[1] : a[3];
        var t = a[2] < a[4] ? a[2] : a[4];
        var w = Math.abs(a[1] - a[3]);
        var h = Math.abs(a[2] - a[4]);
        var y1 = 0;
        var y2 = 0;
        if (a[2] < a[4]) {
            y1 = 0;
            y2 = h;
        } else {
            y1 = h;
            y2 = 0;
        }
        var ln = $($("!div:div_" + a[0]).abs().pos(l - 25, t - 25),
            "!svg:svg_" + a[0] + ",width=" + (w + 50) + ",height=" + (h + 50))
            .line("line_" + a[0], 25, 25 + y1, w + 25, 25 + y2);
        ln.kill = $("#div_" + a[0]).kill;
        ln.rotate = $("#div_" + a[0]).rotate;
        ln.pos = function () {
            if (arguments.length == 0) {
                var p = $("#div_" + bargs[0]).pos();
                return [p[0] + 25, p[1] + 25];
            }
            $("#div_" + bargs[0]).pos(arguments[0] - 25, arguments[1] - 25);
            return ln;
        }
        ln.bounds = function () {
            if (arguments.length == 0) {
                var p = ln.pos();
                return [
                    p[0] + parseInt(ln.x1()) - 25,
                    p[1] + parseInt(ln.y1()) - 25,
                    p[0] + parseInt(ln.x2()) - 25,
                    p[1] + parseInt(ln.y2()) - 25
                ];
            }
            var a = arguments;
            var l = a[0] < a[2] ? a[0] : a[2];
            var t = a[1] < a[3] ? a[1] : a[3];
            var w = Math.abs(a[0] - a[2]);
            var h = Math.abs(a[1] - a[3]);
            var y1 = 0;
            var y2 = 0;
            if (arguments[1] < arguments[3]) {
                y1 = 0;
                y2 = h;
            } else {
                y1 = h;
                y2 = 0;
            }
            ln.pos(l, t);

            $("#svg_" + bargs[0]).sz(w + 50, h + 50);
            ln.x1(25).y1(25 + y1).x2(25 + w).y2(25 + y2);
            return ln;
        }

        return ln;
    }
    return ret;
}

main = function () { }