// JScript File
ReadyObject = {
    isReady: false,
    init: function() {
        this.isReady = true;
    },
    ready: function(func) {
        AGBB.ExecQueue.add(func, function() { return this.isReady; }, this);
    }
};
AGBB = $.extend
    ({
        path: '/DesktopModules',
        rootURL: '/DesktopModules',
        allLinks: [],
        allOrderedLinks: [],
        version: 1.0,
        //lay du lieu tu url va 1 the
        loadData: function(Name, Url) {

            $('#' + Name).html(AGBB.template(Url, ''));

        },
        loadDataJs: function(url, func) {
            AGBB.ajax({
                url: url,
                async: true,
                cache: true,
                success: function(data) {
                    eval(data);
                    eval(func);
                }
            });
        },
        //chen du lieu vao the html
        AppendDataHtml: function(Name, url) {

            $('#' + Name).append(AGBB.template(url, ''));

        },
        loadjs: function(Name, url, func) {
            $.ajax({
                url: url,
                async: false,
                cache: true,
                success: function(data) {
                    $('#' + Name).append('<script>' + data + '</script>');
                    if (typeof (func == 'function')) {
                        func.call(this);
                    };
                }
            });
        },
        loadjsIntoBody: function(url, func) {
            AGBB.ajax({
                url: url,
                async: false,
                cache: true,
                success: function(data) {
                    AGBB('body').append('<script>' + data + '</script>');
                    if (typeof (func == 'function')) {
                        func.call(this);
                    };
                }
            });
        },
        template: function(id, data) {
            return $.fn.pureJSTemplate({
                id: id,
                data: data
            });
        },
        request: function(param, defaultValue) {
            if (typeof (defaultValue) == 'undefined') {
                defaultValue = '';
            }
            var regex = '[?&]' + param + '=([^&#]*)';
            var results = (new RegExp(regex)).exec(location.href);
            if (results) return results[1];
            else {
                regex = '[?/]' + param + '/([^/#]*)';
                results = (new RegExp(regex)).exec(location.href);
                if (results) return results[1];
            }
            return defaultValue;
        },
        xml: function(fn, path) {
            return AGBB.xmlToJson($(path, AGBB.read(fn, { dataType: 'xml', async: false })));
        },
        xmlToJson: function(xmlNode, parentNode) {
            var result = {}, count = 0, isArray = false;
            if (xmlNode.children) {
                xmlNode.children().each(function() {
                    var children = $(this).children(), key;
                    if (count == 0 && typeof (result[this.tagName]) == 'undefined' && !isArray) {
                        if (typeof (parentNode) != 'undefined' && parentNode == this.tagName + 's') {
                            key = 0;
                            isArray = true;
                            result = [];
                        }
                        else {
                            key = this.tagName;
                        }
                    }
                    else {
                        if (count == 0 && typeof (result[this.tagName]) != 'undefined') {
                            result = [result[this.tagName]];
                        }
                        key = ++count;
                    }
                    if (children.length > 0) {
                        result[key] = AGBB.xmlToJson($(this), key);
                    }
                    else {
                        result[key] = $(this).text();
                    }
                    children = null;
                    //result[key]._index = count;
                });
            }
            else {
                return xmlNode;
            }
            return result;
        },

        read: function(fileName, options, func) {
            if (!fileName) return;
            //            if (AGBB.allLinks[fileName]) {
            //                return;
            //            }
            if (typeof (options) == 'function') {
                func = options;
                options = {};
            }
            if (!options) {
                options = {};
            }
            if (!options.dataType) {
                options.dataType = 'html';
            }
            if (fileName.indexOf('http://') != -1) {
                $('#includeJs').append('<' + 'script src="' + fileName + '"><' + '/script>');
                AGBB.allLinks[fileName] = 2;
                AGBB.allOrderedLinks.push(fileName);
            }
            else {
                if (fileName.indexOf('.css') != -1) {
                    $('#includeJs').append('<link rel="stylesheet" type="text/css" href="' + fileName + '">');
                    AGBB.allLinks[fileName] = 2;
                    AGBB.allOrderedLinks.push(fileName);
                    return;
                }
                if (fileName.indexOf('.js') != -1) {

                    var node = document.createElement('SCRIPT');
                    node.src = fileName;
                    document.body.appendChild(node);
                    if ($.browser.msie) {
                        AGBB.ExecQueue.add(function() {
                            AGBB.allLinks[fileName] = 2;
                            AGBB.allOrderedLinks.push(fileName);
                            if (func) func.call(this);
                        }, function() {
                            return node.readyState == 'complete' || node.readyState == 'loaded';
                        });
                    }
                    else {
                        var node2 = document.createElement('SCRIPT');
                        node2.text = 'AGBB.allLinks["' + fileName + '"] = 2; AGBB.allOrderedLinks.push("' + fileName + '");';
                        document.body.appendChild(node2);
                        if (func)
                            AGBB.ExecQueue.add(function() {
                                func.call(this);
                            }, function() {
                                return AGBB.allLinks[fileName] >= 2;
                            });
                    }

                }
                var returnValue = '';
                AGBB.allLinks[fileName] = 1;
                $.ajax($.extend({
                    url: fileName + (/\?/.test(fileName) ? '&' : '?') + 'v=' + AGBB.version,
                    cache: true,
                    success: function(data) {
                        if (options.dataType == 'html') {
                            if (fileName.indexOf('.css') != -1) {
                                var parts = fileName.split('/');
                                parts.splice(parts.length - 1, 1);
                                parts = parts.join('/') + '/';
                                data = data.replace(/url\s*\(\s*(["']?)/gi, 'url($1' + parts);
                                $('#includeJs').append('<style>' + data + '</style>');
                            }
                            else
                                if (fileName.indexOf('.js') != -1) {
                                //try {
                                eval(data);
                                //} catch (e) {}
                            }
                        }
                        else {
                            returnValue = data;
                        }
                        AGBB.allLinks[fileName] = 2;
                        AGBB.allOrderedLinks.push(fileName);
                        if (func) {
                            func.call(this, data);
                        }
                    }
                }, options));
                return returnValue;
            }
        },

        getComponentURL: function(url) {

            var values = { path: '', type: '' };
            if (url.indexOf('http://') != -1) {
                values.path = AGBB.rootURL + 'get.php?url=' + encodeURI(url);
                values.type = 'cross-domain';
            }
            else if (url.indexOf('3rdparty') != -1) {
                values.path = AGBB.rootURL + url;
                values.type = '3rdparty';

            }
            else if (url.indexOf('.') != -1) {
                //var parts = url.split('.');
                //values.package = parts[0];
                //parts.shift();

                //values.path = AGBB.rootURL + 'packages/' + values.package + '/modules/' + parts.join('.') + '.js';
                values.path = AGBB.rootURL + url;
                values.type = 'App-Region';
            }
            else if (url.indexOf('/App/region/') != -1) {
                values.path = AGBB.rootURL + url + '.js';
                values.type = 'App-Region';
            }
            else {
                values.packagePath = AGBB.rootURL + 'packages/' + url + '/';
                values.path = values.packagePath + 'modules/' + url + '.js';
                values.type = 'package';

            }

            return values;
        },

        load: function() {
            var args = [];
            if (arguments.length > 0) {
                if (typeof (arguments[0]) == 'function') {
                    arguments[0].call(this);
                }
                else {
                    var length = arguments.length;
                    if (typeof (arguments[arguments.length - 1]) == 'function') {
                        length--;
                    }
                    if (typeof (arguments[0]) == 'object' && arguments[0].length && typeof (arguments[0][0]) == 'object' && arguments[0][0].length) {
                        var args = arguments;
                        var newArgs = args[0].splice(0, 1)[0];
                        if (args[0].length > 0) {
                            newArgs.push(function() {
                                AGBB.load(args[0], args[1]);
                            });
                        }
                        else {
                            newArgs.push(args[1]);
                        }
                        AGBB.load.apply(this, newArgs);
                        return;
                    }

                    for (var i = 0; i < length; i++) {
                        if (typeof (arguments[i]) == 'string') {
                            args[i] = AGBB.getComponentURL(arguments[i]);
                            args[i].name = arguments[i];
                            if (!AGBB.allLinks[args[i].path]) {
                                if (args[i].type == 'module') {
                                    var parts = arguments[i].split('.');
                                    var files = [];

                                    for (var j = 0; j < parts.length - 1; j++) {
                                        var file = parts.slice(0, j + 1).join('.');
                                        var url2 = AGBB.getComponentURL(file);
                                        if (!AGBB.allLinks[url2.path] || AGBB.allLinks[url2.path] < 2) {
                                            files.push(file);
                                        }
                                    }
                                    if (files.length > 0) {
                                        var thisPath = arguments[i];
                                        files.push(function() { AGBB.load(thisPath) });
                                        AGBB.load.apply(this, files);
                                        continue;
                                    }
                                }
                                var currentArg = args[i];

                                AGBB.read(args[i].path, function() {
                                    switch (currentArg.type) {
                                        case 'package':
                                            Lang.$import(currentArg.packagePath + 'languages/' + AGBB.language + '.js');
                                            if (AGBB[currentArg.name] && typeof (AGBB[currentArg.name].init) == 'function') {
                                                AGBB[currentArg.name].init();
                                            }
                                            break;
                                    }
                                });
                            }
                        }
                    }
                    if (typeof (arguments[length]) == 'function') {
                        var oldArgs = arguments;


                        AGBB.ExecQueue.add(function() {
                            oldArgs[length].call(this);
                        }, function() {
                            for (var i = 0; i < length; i++) {

                                if (!AGBB.allLinks[args[i].path] || AGBB.allLinks[args[i].path] < 2) {
                                    return false;
                                }
                                else if (args[i].type == 'module' && args[i].name.substr(0, 3) != 'AGBB.') {
                                    var ok = true;
                                    try {
                                        eval('$ok = (typeof(AGBB.' + args[i].name + ') != "undefined");');
                                    }
                                    catch (e) {
                                        $ok = false;
                                    };
                                    if (!$ok) {
                                        return false;
                                    }
                                }
                            }
                            return true;
                        }, arguments);
                    }
                }
            }
        },
        init: function() {
            if (typeof (AGBB.allLinks) == 'undefined') {
                AGBB.allLinks = {};
                //AGBB.allLinks[AGBB.rootURL+'3rdparty/jQuery/jquery-1.3.2.min.js'] = 2;
                //AGBB.allLinks[AGBB.rootURL+'packages/AGBB/modules/AGBB.js'] = 2;

                var loader = jQuery('<div id="loader"><img src="' + AGBB.path + '/loading.gif" alt="loading..." /></div>')
				        .css({ position: "absolute", top: "1em", left: "1em" })
				        .appendTo("#ContentAGBB")
				        .hide();
                jQuery().ajaxStart(function() {
                    loader.show();
                }).ajaxStop(function() {
                    loader.hide();
                }).ajaxError(function(a, b, e) {
                    //throw e;
                });
                AGBB.run();
                //AGBB.load('/js/3rdparty/jQuery/jquery.cookies.js','/js/3rdparty/jQuery/purejstemplate_jquery.js', function(){AGBB.run();});         


            }
        },
        run: function() {
            AGBB.load('/App/App.js', function() { AGBB.App.init(); });
            //AGBB.loadjs('includeJs', AGBB.path + '/App/App.js', function() {if(typeof (AGBB.App) != 'undefined') AGBB.App.init(); else AGBB.run(); });
        }
    });
AGBB.ExecQueue = {
    queue: [],
    isRunning: false,
    interval: false,
    run: function() {
        if (!this.interval) {
            this.interval = setInterval(this.intervalFunction, 10);
        }
    },
    intervalFunction: function() {
        if (!AGBB.ExecQueue.isRunning) {
            AGBB.ExecQueue.isRunning = true;
            for (var i = 0; i < AGBB.ExecQueue.queue.length; i++) {
                if ((AGBB.ExecQueue.queue[i].isLoop || !AGBB.ExecQueue.queue[i].isCalled) && AGBB.ExecQueue.queue[i].condition.call(AGBB.ExecQueue.queue[i].context)) {
                    AGBB.ExecQueue.queue[i].isCalled = true;
                    AGBB.ExecQueue.queue[i].callback.call(AGBB.ExecQueue.queue[i].context);
                }
            }
            var i = 0;
            while (i < AGBB.ExecQueue.queue.length) {
                if (AGBB.ExecQueue.queue[i].isCalled && !AGBB.ExecQueue.queue[i].isLoop) {
                    AGBB.ExecQueue.queue.splice(i, 1);
                }
                else {
                    i++;
                }
            }
            if (AGBB.ExecQueue.queue.length == 0) {
                clearInterval(AGBB.ExecQueue.interval);
                AGBB.ExecQueue.interval = false;
            }
            AGBB.ExecQueue.isRunning = false;
        }
    },
    add: function(callback, condition, context, isLoop) {
        this.queue.push({
            callback: callback,
            condition: condition,
            context: context,
            isLoop: isLoop ? true : false,
            isCalled: false
        });
        if (!this.interval) {
            this.run();
        }
    }
};

Encoder = {

    // When encoding do we convert characters into html or numerical entities
    EncodeType: "entity",  // entity OR numerical

    isEmpty: function(val) {
        if (val) {
            return ((val === null) || val.length == 0 || /^\s+$/.test(val));
        } else {
            return true;
        }
    },
    // Convert HTML entities into numerical entities
    HTML2Numerical: function(s) {
        var arr1 = new Array('&nbsp;', '&iexcl;', '&cent;', '&pound;', '&curren;', '&yen;', '&brvbar;', '&sect;', '&uml;', '&copy;', '&ordf;', '&laquo;', '&not;', '&shy;', '&reg;', '&macr;', '&deg;', '&plusmn;', '&sup2;', '&sup3;', '&acute;', '&micro;', '&para;', '&middot;', '&cedil;', '&sup1;', '&ordm;', '&raquo;', '&frac14;', '&frac12;', '&frac34;', '&iquest;', '&agrave;', '&aacute;', '&acirc;', '&atilde;', '&Auml;', '&aring;', '&aelig;', '&ccedil;', '&egrave;', '&eacute;', '&ecirc;', '&euml;', '&igrave;', '&iacute;', '&icirc;', '&iuml;', '&eth;', '&ntilde;', '&ograve;', '&oacute;', '&ocirc;', '&otilde;', '&Ouml;', '&times;', '&oslash;', '&ugrave;', '&uacute;', '&ucirc;', '&Uuml;', '&yacute;', '&thorn;', '&szlig;', '&agrave;', '&aacute;', '&acirc;', '&atilde;', '&auml;', '&aring;', '&aelig;', '&ccedil;', '&egrave;', '&eacute;', '&ecirc;', '&euml;', '&igrave;', '&iacute;', '&icirc;', '&iuml;', '&eth;', '&ntilde;', '&ograve;', '&oacute;', '&ocirc;', '&otilde;', '&ouml;', '&divide;', '&oslash;', '&ugrave;', '&uacute;', '&ucirc;', '&uuml;', '&yacute;', '&thorn;', '&yuml;', '&quot;', '&amp;', '&lt;', '&gt;', '&oelig;', '&oelig;', '&scaron;', '&scaron;', '&yuml;', '&circ;', '&tilde;', '&ensp;', '&emsp;', '&thinsp;', '&zwnj;', '&zwj;', '&lrm;', '&rlm;', '&ndash;', '&mdash;', '&lsquo;', '&rsquo;', '&sbquo;', '&ldquo;', '&rdquo;', '&bdquo;', '&dagger;', '&dagger;', '&permil;', '&lsaquo;', '&rsaquo;', '&euro;', '&fnof;', '&alpha;', '&beta;', '&gamma;', '&delta;', '&epsilon;', '&zeta;', '&eta;', '&theta;', '&iota;', '&kappa;', '&lambda;', '&mu;', '&nu;', '&xi;', '&omicron;', '&pi;', '&rho;', '&sigma;', '&tau;', '&upsilon;', '&phi;', '&chi;', '&psi;', '&omega;', '&alpha;', '&beta;', '&gamma;', '&delta;', '&epsilon;', '&zeta;', '&eta;', '&theta;', '&iota;', '&kappa;', '&lambda;', '&mu;', '&nu;', '&xi;', '&omicron;', '&pi;', '&rho;', '&sigmaf;', '&sigma;', '&tau;', '&upsilon;', '&phi;', '&chi;', '&psi;', '&omega;', '&thetasym;', '&upsih;', '&piv;', '&bull;', '&hellip;', '&prime;', '&prime;', '&oline;', '&frasl;', '&weierp;', '&image;', '&real;', '&trade;', '&alefsym;', '&larr;', '&uarr;', '&rarr;', '&darr;', '&harr;', '&crarr;', '&larr;', '&uarr;', '&rarr;', '&darr;', '&harr;', '&forall;', '&part;', '&exist;', '&empty;', '&nabla;', '&isin;', '&notin;', '&ni;', '&prod;', '&sum;', '&minus;', '&lowast;', '&radic;', '&prop;', '&infin;', '&ang;', '&and;', '&or;', '&cap;', '&cup;', '&int;', '&there4;', '&sim;', '&cong;', '&asymp;', '&ne;', '&equiv;', '&le;', '&ge;', '&sub;', '&sup;', '&nsub;', '&sube;', '&supe;', '&oplus;', '&otimes;', '&perp;', '&sdot;', '&lceil;', '&rceil;', '&lfloor;', '&rfloor;', '&lang;', '&rang;', '&loz;', '&spades;', '&clubs;', '&hearts;', '&diams;');
        var arr2 = new Array('&#160;', '&#161;', '&#162;', '&#163;', '&#164;', '&#165;', '&#166;', '&#167;', '&#168;', '&#169;', '&#170;', '&#171;', '&#172;', '&#173;', '&#174;', '&#175;', '&#176;', '&#177;', '&#178;', '&#179;', '&#180;', '&#181;', '&#182;', '&#183;', '&#184;', '&#185;', '&#186;', '&#187;', '&#188;', '&#189;', '&#190;', '&#191;', '&#192;', '&#193;', '&#194;', '&#195;', '&#196;', '&#197;', '&#198;', '&#199;', '&#200;', '&#201;', '&#202;', '&#203;', '&#204;', '&#205;', '&#206;', '&#207;', '&#208;', '&#209;', '&#210;', '&#211;', '&#212;', '&#213;', '&#214;', '&#215;', '&#216;', '&#217;', '&#218;', '&#219;', '&#220;', '&#221;', '&#222;', '&#223;', '&#224;', '&#225;', '&#226;', '&#227;', '&#228;', '&#229;', '&#230;', '&#231;', '&#232;', '&#233;', '&#234;', '&#235;', '&#236;', '&#237;', '&#238;', '&#239;', '&#240;', '&#241;', '&#242;', '&#243;', '&#244;', '&#245;', '&#246;', '&#247;', '&#248;', '&#249;', '&#250;', '&#251;', '&#252;', '&#253;', '&#254;', '&#255;', '&#34;', '&#38;', '&#60;', '&#62;', '&#338;', '&#339;', '&#352;', '&#353;', '&#376;', '&#710;', '&#732;', '&#8194;', '&#8195;', '&#8201;', '&#8204;', '&#8205;', '&#8206;', '&#8207;', '&#8211;', '&#8212;', '&#8216;', '&#8217;', '&#8218;', '&#8220;', '&#8221;', '&#8222;', '&#8224;', '&#8225;', '&#8240;', '&#8249;', '&#8250;', '&#8364;', '&#402;', '&#913;', '&#914;', '&#915;', '&#916;', '&#917;', '&#918;', '&#919;', '&#920;', '&#921;', '&#922;', '&#923;', '&#924;', '&#925;', '&#926;', '&#927;', '&#928;', '&#929;', '&#931;', '&#932;', '&#933;', '&#934;', '&#935;', '&#936;', '&#937;', '&#945;', '&#946;', '&#947;', '&#948;', '&#949;', '&#950;', '&#951;', '&#952;', '&#953;', '&#954;', '&#955;', '&#956;', '&#957;', '&#958;', '&#959;', '&#960;', '&#961;', '&#962;', '&#963;', '&#964;', '&#965;', '&#966;', '&#967;', '&#968;', '&#969;', '&#977;', '&#978;', '&#982;', '&#8226;', '&#8230;', '&#8242;', '&#8243;', '&#8254;', '&#8260;', '&#8472;', '&#8465;', '&#8476;', '&#8482;', '&#8501;', '&#8592;', '&#8593;', '&#8594;', '&#8595;', '&#8596;', '&#8629;', '&#8656;', '&#8657;', '&#8658;', '&#8659;', '&#8660;', '&#8704;', '&#8706;', '&#8707;', '&#8709;', '&#8711;', '&#8712;', '&#8713;', '&#8715;', '&#8719;', '&#8721;', '&#8722;', '&#8727;', '&#8730;', '&#8733;', '&#8734;', '&#8736;', '&#8743;', '&#8744;', '&#8745;', '&#8746;', '&#8747;', '&#8756;', '&#8764;', '&#8773;', '&#8776;', '&#8800;', '&#8801;', '&#8804;', '&#8805;', '&#8834;', '&#8835;', '&#8836;', '&#8838;', '&#8839;', '&#8853;', '&#8855;', '&#8869;', '&#8901;', '&#8968;', '&#8969;', '&#8970;', '&#8971;', '&#9001;', '&#9002;', '&#9674;', '&#9824;', '&#9827;', '&#9829;', '&#9830;');
        return this.swapArrayVals(s, arr1, arr2);
    },

    // Convert Numerical entities into HTML entities
    NumericalToHTML: function(s) {
        var arr1 = new Array('&#160;', '&#161;', '&#162;', '&#163;', '&#164;', '&#165;', '&#166;', '&#167;', '&#168;', '&#169;', '&#170;', '&#171;', '&#172;', '&#173;', '&#174;', '&#175;', '&#176;', '&#177;', '&#178;', '&#179;', '&#180;', '&#181;', '&#182;', '&#183;', '&#184;', '&#185;', '&#186;', '&#187;', '&#188;', '&#189;', '&#190;', '&#191;', '&#192;', '&#193;', '&#194;', '&#195;', '&#196;', '&#197;', '&#198;', '&#199;', '&#200;', '&#201;', '&#202;', '&#203;', '&#204;', '&#205;', '&#206;', '&#207;', '&#208;', '&#209;', '&#210;', '&#211;', '&#212;', '&#213;', '&#214;', '&#215;', '&#216;', '&#217;', '&#218;', '&#219;', '&#220;', '&#221;', '&#222;', '&#223;', '&#224;', '&#225;', '&#226;', '&#227;', '&#228;', '&#229;', '&#230;', '&#231;', '&#232;', '&#233;', '&#234;', '&#235;', '&#236;', '&#237;', '&#238;', '&#239;', '&#240;', '&#241;', '&#242;', '&#243;', '&#244;', '&#245;', '&#246;', '&#247;', '&#248;', '&#249;', '&#250;', '&#251;', '&#252;', '&#253;', '&#254;', '&#255;', '&#34;', '&#38;', '&#60;', '&#62;', '&#338;', '&#339;', '&#352;', '&#353;', '&#376;', '&#710;', '&#732;', '&#8194;', '&#8195;', '&#8201;', '&#8204;', '&#8205;', '&#8206;', '&#8207;', '&#8211;', '&#8212;', '&#8216;', '&#8217;', '&#8218;', '&#8220;', '&#8221;', '&#8222;', '&#8224;', '&#8225;', '&#8240;', '&#8249;', '&#8250;', '&#8364;', '&#402;', '&#913;', '&#914;', '&#915;', '&#916;', '&#917;', '&#918;', '&#919;', '&#920;', '&#921;', '&#922;', '&#923;', '&#924;', '&#925;', '&#926;', '&#927;', '&#928;', '&#929;', '&#931;', '&#932;', '&#933;', '&#934;', '&#935;', '&#936;', '&#937;', '&#945;', '&#946;', '&#947;', '&#948;', '&#949;', '&#950;', '&#951;', '&#952;', '&#953;', '&#954;', '&#955;', '&#956;', '&#957;', '&#958;', '&#959;', '&#960;', '&#961;', '&#962;', '&#963;', '&#964;', '&#965;', '&#966;', '&#967;', '&#968;', '&#969;', '&#977;', '&#978;', '&#982;', '&#8226;', '&#8230;', '&#8242;', '&#8243;', '&#8254;', '&#8260;', '&#8472;', '&#8465;', '&#8476;', '&#8482;', '&#8501;', '&#8592;', '&#8593;', '&#8594;', '&#8595;', '&#8596;', '&#8629;', '&#8656;', '&#8657;', '&#8658;', '&#8659;', '&#8660;', '&#8704;', '&#8706;', '&#8707;', '&#8709;', '&#8711;', '&#8712;', '&#8713;', '&#8715;', '&#8719;', '&#8721;', '&#8722;', '&#8727;', '&#8730;', '&#8733;', '&#8734;', '&#8736;', '&#8743;', '&#8744;', '&#8745;', '&#8746;', '&#8747;', '&#8756;', '&#8764;', '&#8773;', '&#8776;', '&#8800;', '&#8801;', '&#8804;', '&#8805;', '&#8834;', '&#8835;', '&#8836;', '&#8838;', '&#8839;', '&#8853;', '&#8855;', '&#8869;', '&#8901;', '&#8968;', '&#8969;', '&#8970;', '&#8971;', '&#9001;', '&#9002;', '&#9674;', '&#9824;', '&#9827;', '&#9829;', '&#9830;');
        var arr2 = new Array('&nbsp;', '&iexcl;', '&cent;', '&pound;', '&curren;', '&yen;', '&brvbar;', '&sect;', '&uml;', '&copy;', '&ordf;', '&laquo;', '&not;', '&shy;', '&reg;', '&macr;', '&deg;', '&plusmn;', '&sup2;', '&sup3;', '&acute;', '&micro;', '&para;', '&middot;', '&cedil;', '&sup1;', '&ordm;', '&raquo;', '&frac14;', '&frac12;', '&frac34;', '&iquest;', '&agrave;', '&aacute;', '&acirc;', '&atilde;', '&Auml;', '&aring;', '&aelig;', '&ccedil;', '&egrave;', '&eacute;', '&ecirc;', '&euml;', '&igrave;', '&iacute;', '&icirc;', '&iuml;', '&eth;', '&ntilde;', '&ograve;', '&oacute;', '&ocirc;', '&otilde;', '&Ouml;', '&times;', '&oslash;', '&ugrave;', '&uacute;', '&ucirc;', '&Uuml;', '&yacute;', '&thorn;', '&szlig;', '&agrave;', '&aacute;', '&acirc;', '&atilde;', '&auml;', '&aring;', '&aelig;', '&ccedil;', '&egrave;', '&eacute;', '&ecirc;', '&euml;', '&igrave;', '&iacute;', '&icirc;', '&iuml;', '&eth;', '&ntilde;', '&ograve;', '&oacute;', '&ocirc;', '&otilde;', '&ouml;', '&divide;', '&oslash;', '&ugrave;', '&uacute;', '&ucirc;', '&uuml;', '&yacute;', '&thorn;', '&yuml;', '&quot;', '&amp;', '&lt;', '&gt;', '&oelig;', '&oelig;', '&scaron;', '&scaron;', '&yuml;', '&circ;', '&tilde;', '&ensp;', '&emsp;', '&thinsp;', '&zwnj;', '&zwj;', '&lrm;', '&rlm;', '&ndash;', '&mdash;', '&lsquo;', '&rsquo;', '&sbquo;', '&ldquo;', '&rdquo;', '&bdquo;', '&dagger;', '&dagger;', '&permil;', '&lsaquo;', '&rsaquo;', '&euro;', '&fnof;', '&alpha;', '&beta;', '&gamma;', '&delta;', '&epsilon;', '&zeta;', '&eta;', '&theta;', '&iota;', '&kappa;', '&lambda;', '&mu;', '&nu;', '&xi;', '&omicron;', '&pi;', '&rho;', '&sigma;', '&tau;', '&upsilon;', '&phi;', '&chi;', '&psi;', '&omega;', '&alpha;', '&beta;', '&gamma;', '&delta;', '&epsilon;', '&zeta;', '&eta;', '&theta;', '&iota;', '&kappa;', '&lambda;', '&mu;', '&nu;', '&xi;', '&omicron;', '&pi;', '&rho;', '&sigmaf;', '&sigma;', '&tau;', '&upsilon;', '&phi;', '&chi;', '&psi;', '&omega;', '&thetasym;', '&upsih;', '&piv;', '&bull;', '&hellip;', '&prime;', '&prime;', '&oline;', '&frasl;', '&weierp;', '&image;', '&real;', '&trade;', '&alefsym;', '&larr;', '&uarr;', '&rarr;', '&darr;', '&harr;', '&crarr;', '&larr;', '&uarr;', '&rarr;', '&darr;', '&harr;', '&forall;', '&part;', '&exist;', '&empty;', '&nabla;', '&isin;', '&notin;', '&ni;', '&prod;', '&sum;', '&minus;', '&lowast;', '&radic;', '&prop;', '&infin;', '&ang;', '&and;', '&or;', '&cap;', '&cup;', '&int;', '&there4;', '&sim;', '&cong;', '&asymp;', '&ne;', '&equiv;', '&le;', '&ge;', '&sub;', '&sup;', '&nsub;', '&sube;', '&supe;', '&oplus;', '&otimes;', '&perp;', '&sdot;', '&lceil;', '&rceil;', '&lfloor;', '&rfloor;', '&lang;', '&rang;', '&loz;', '&spades;', '&clubs;', '&hearts;', '&diams;');
        return this.swapArrayVals(s, arr1, arr2);
    },


    // Numerically encodes all unicode characters
    numEncode: function(s) {

        if (this.isEmpty(s)) return "";

        var e = "";
        for (var i = 0; i < s.length; i++) {
            var c = s.charAt(i);
            if (c < " " || c > "~") {
                c = "&#" + c.charCodeAt() + ";";
            }
            e += c;
        }
        return e;
    },

    // HTML Decode numerical and HTML entities back to original values
    htmlDecode: function(s) {

        var c, m, d = s;

        if (this.isEmpty(d)) return "";

        // convert HTML entites back to numerical entites first
        d = this.HTML2Numerical(d);

        // look for numerical entities &#34;
        arr = d.match(/&#[0-9]{1,5};/g);

        // if no matches found in string then skip
        if (arr != null) {
            for (var x = 0; x < arr.length; x++) {
                m = arr[x];
                c = m.substring(2, m.length - 1); //get numeric part which is refernce to unicode character
                // if its a valid number we can decode
                if (c >= -32768 && c <= 65535) {
                    // decode every single match within string
                    d = d.replace(m, String.fromCharCode(c));
                } else {
                    d = d.replace(m, ""); //invalid so replace with nada
                }
            }
        }

        return d;
    },

    // encode an input string into either numerical or HTML entities
    htmlEncode: function(s, dbl) {

        if (this.isEmpty(s)) return "";

        // do we allow double encoding? E.g will &amp; be turned into &amp;amp;
        dbl = dbl | false; //default to prevent double encoding

        // if allowing double encoding we do ampersands first
        if (dbl) {
            if (this.EncodeType == "numerical") {
                s = s.replace(/&/g, "&#38;");
            } else {
                s = s.replace(/&/g, "&amp;");
            }
        }

        // convert the xss chars to numerical entities ' " < >
        s = this.XSSEncode(s, false);

        if (this.EncodeType == "numerical" || !dbl) {
            // Now call function that will convert any HTML entities to numerical codes
            s = this.HTML2Numerical(s);
        }

        // Now encode all chars above 127 e.g unicode
        s = this.numEncode(s);

        // now we know anything that needs to be encoded has been converted to numerical entities we
        // can encode any ampersands & that are not part of encoded entities
        // to handle the fact that I need to do a negative check and handle multiple ampersands &&&
        // I am going to use a placeholder

        // if we don't want double encoded entities we ignore the & in existing entities
        if (!dbl) {
            s = s.replace(/&#/g, "##AMPHASH##");

            if (this.EncodeType == "numerical") {
                s = s.replace(/&/g, "&#38;");
            } else {
                s = s.replace(/&/g, "&amp;");
            }

            s = s.replace(/##AMPHASH##/g, "&#");
        }

        // replace any malformed entities
        s = s.replace(/&#\d*([^\d;]|$)/g, "$1");

        if (!dbl) {
            // safety check to correct any double encoded &amp;
            s = this.correctEncoding(s);
        }

        // now do we need to convert our numerical encoded string into entities
        if (this.EncodeType == "entity") {
            s = this.NumericalToHTML(s);
        }

        return s;
    },

    // Encodes the basic 4 characters used to malform HTML in XSS hacks
    XSSEncode: function(s, en) {
        if (!this.isEmpty(s)) {
            en = en || true;
            // do we convert to numerical or html entity?
            if (en) {
                s = s.replace(/\'/g, "&#39;"); //no HTML equivalent as &apos is not cross browser supported
                s = s.replace(/\"/g, "&quot;");
                s = s.replace(/</g, "&lt;");
                s = s.replace(/>/g, "&gt;");
            } else {
                s = s.replace(/\'/g, "&#39;"); //no HTML equivalent as &apos is not cross browser supported
                s = s.replace(/\"/g, "&#34;");
                s = s.replace(/</g, "&#60;");
                s = s.replace(/>/g, "&#62;");
            }
            return s;
        } else {
            return "";
        }
    },

    // returns true if a string contains html or numerical encoded entities
    hasEncoded: function(s) {
        if (/&#[0-9]{1,5};/g.test(s)) {
            return true;
        } else if (/&[A-Z]{2,6};/gi.test(s)) {
            return true;
        } else {
            return false;
        }
    },

    // will remove any unicode characters
    stripUnicode: function(s) {
        return s.replace(/[^\x20-\x7E]/g, "");

    },

    // corrects any double encoded &amp; entities e.g &amp;amp;
    correctEncoding: function(s) {
        return s.replace(/(&amp;)(amp;)+/, "$1");
    },


    // Function to loop through an array swaping each item with the value from another array e.g swap HTML entities with Numericals
    swapArrayVals: function(s, arr1, arr2) {
        if (this.isEmpty(s)) return "";
        var re;
        if (arr1 && arr2) {
            //ShowDebug("in swapArrayVals arr1.length = " + arr1.length + " arr2.length = " + arr2.length)
            // array lengths must match
            if (arr1.length == arr2.length) {
                for (var x = 0, i = arr1.length; x < i; x++) {
                    re = new RegExp(arr1[x], 'g');
                    s = s.replace(re, arr2[x]); //swap arr1 item with matching item from arr2	
                }
            }
        }
        return s;
    },

    inArray: function(item, arr) {
        for (var i = 0, x = arr.length; i < x; i++) {
            if (arr[i] === item) {
                return i;
            }
        }
        return -1;
    },
    ConvertStringToDayMonthYear: function(strDate) {
        alert(strDate);
        var date = new Date(strDate);
        var month;
        if (date.getMonth() == 0) {
            month = "01";
        }
        else {

            month = date.getMonth() + 1;
            if (month <= 9) {
                month = "0" + month;
            }
        };
        var day = date.getDate();
        if (day <= 9) {
            day = "0" + day;
        };
        alert("2");
        return day + '/' + month + '/' + date.getFullYear();
    }

}

//AGBB.init();


//Hàm thư viện Ngày tháng CreateBy TuanN
DateUtils = {
    ConvertStringToDayMonthYear: function (strDate) {
        var date = new Date(strDate);
        var month;
        if (date.getMonth() == 0) {
            month = "01";
        }
        else {
            month = date.getMonth() + 1;
            if (month <= 9) {
                month = "0" + month;
            }
        };
        var day = date.getDate();
        if (day <= 9) {
            day = "0" + day;
        };
        return day + '/' + month + '/' + date.getFullYear();
    },
    ConvertStringToHourMinus: function (strDate) {
        var date = new Date(strDate);
        var gio = date.getHours();
        if (gio == 0) {
            gio = "12";
        }
        else {
            if (gio <= 9) {
                gio = "0" + gio;
            }
        };
        var phut = date.getMinutes();
        if (phut <= 9) {
            phut = "0" + phut;
        }
        return gio + ':' + phut;
    }
    ,
    ConvertStringToHourMinusSecond: function (strDate) {
        var date = new Date(strDate);
        var gio = date.getHours();
        if (gio == 0) {
            gio = "12";
        }
        else {
            if (gio <= 9) {
                gio = "0" + gio;
            }
        };
        var phut = date.getMinutes();
        if (phut <= 9) {
            phut = "0" + phut;
        }
        var giay = date.getSeconds();
        if (giay <= 9) {
            giay = "0" + giay;
        }
        return gio + ':' + phut + ':' + giay;
    }
    , ConvertVietNameseToEnglish: function (strDate) {
        var arrDay = strDate.split('/');
        return arrDay[1] + '/' + arrDay[0] + '/' + arrDay[2];
    },
    ConvertEnglishToVietNamese: function (strDate) {
        var arrDay = strDate.split('/');
        if (parseInt(arrDay[0]) <= 9) {
            arrDay[0] = "0" + arrDay[0];
        }
        if (parseInt(arrDay[1]) <= 9) {
            arrDay[1] = "0" + arrDay[1];
        }
        return arrDay[1] + '/' + arrDay[0] + '/' + arrDay[2];
    },
    GetDateTimeNow: function () {
        var now = new Date();
        var year = now.getYear();
        var month = now.getMonth() + 1;
        var date = now.getDate();
        var hours = now.getHours();
        var minutes = now.getMinutes();
        var seconds = now.getSeconds();
        var time = year.toString() + month.toString() + date.toString() + hours.toString() + minutes.toString() + seconds.toString();
        return time;
    }

};

//Hàm thư viên về String CreateBy TuanN
StringUtils =
    {
        SubStringNotDot: function(current_str, position) {
            var cL = current_str.length;

            var tem;
            //neu nho hon
            if (position < cL) {
                tem = current_str.substring(0, position);
                var pos = tem.lastIndexOf(' ');

                var kaka = tem.substring(0, pos);
                return kaka;

            }
            else {
                return current_str;
            }
        }, //ALD_1279,ASA_1276,A
        SubString: function(current_str, position) {
            var cL = current_str.length;

            var tem;
            //neu nho hon
            if (position < cL) {
                tem = current_str.substring(0, position);
                var pos = tem.lastIndexOf(' ');

                var kaka = tem.substring(0, pos);
                return kaka + '...';

            }
            else {
                return current_str;
            }
        }, //ALD_1279,ASA_1276,ASA_1280
        ReplaceById: function(NewTemplate, ModuleID, StrInput) {
            var returnstr = '';
            if (StrInput.length > 0) {
                var j = StrInput.lastIndexOf(ModuleID);
                var temps = StrInput.substring(0, j);
                var i = temps.lastIndexOf(',');
                if (i == -1) {
                    i = 0;
                }
                if (j == -1) {
                    returnstr = StrInput;
                }
                var temp = '';
                if (i < j) {

                    temp = StrInput.substring(i + 1, j - 1);
                }
                else {

                    temp = StrInput.substring(0, j - 1);
                }
                returnstr = StrInput.replace(temp + ModuleID, NewTemplate + ModuleID);
                //alert("input:" + StrInput + " Output: " + returnstr + "Find: " + temp + ModuleID + " replateby: " + NewTemplate + ModuleID);

            }
            return returnstr;

        }
    }