Subversion Repositories Applications.papyrus

/*
        Copyright (c) 2004-2006, The Dojo Foundation
        All Rights Reserved.

        Licensed under the Academic Free License version 2.1 or above OR the
        modified BSD license. For more information on Dojo licensing, see:

                http://dojotoolkit.org/community/licensing.shtml
*/



dojo.provide("dojo.logging.Logger");
dojo.provide("dojo.logging.LogFilter");
dojo.provide("dojo.logging.Record");
dojo.provide("dojo.log");
dojo.require("dojo.lang.common");
dojo.require("dojo.lang.declare");
dojo.logging.Record = function (logLevel, message) {
        this.level = logLevel;
        this.message = "";
        this.msgArgs = [];
        this.time = new Date();
        if (dojo.lang.isArray(message)) {
                if (message.length > 0 && dojo.lang.isString(message[0])) {
                        this.message = message.shift();
                }
                this.msgArgs = message;
        } else {
                this.message = message;
        }
};
dojo.logging.LogFilter = function (loggerChain) {
        this.passChain = loggerChain || "";
        this.filter = function (record) {
                return true;
        };
};
dojo.logging.Logger = function () {
        this.cutOffLevel = 0;
        this.propagate = true;
        this.parent = null;
        this.data = [];
        this.filters = [];
        this.handlers = [];
};
dojo.extend(dojo.logging.Logger, {_argsToArr:function (args) {
        var ret = [];
        for (var x = 0; x < args.length; x++) {
                ret.push(args[x]);
        }
        return ret;
}, setLevel:function (lvl) {
        this.cutOffLevel = parseInt(lvl);
}, isEnabledFor:function (lvl) {
        return parseInt(lvl) >= this.cutOffLevel;
}, getEffectiveLevel:function () {
        if ((this.cutOffLevel == 0) && (this.parent)) {
                return this.parent.getEffectiveLevel();
        }
        return this.cutOffLevel;
}, addFilter:function (flt) {
        this.filters.push(flt);
        return this.filters.length - 1;
}, removeFilterByIndex:function (fltIndex) {
        if (this.filters[fltIndex]) {
                delete this.filters[fltIndex];
                return true;
        }
        return false;
}, removeFilter:function (fltRef) {
        for (var x = 0; x < this.filters.length; x++) {
                if (this.filters[x] === fltRef) {
                        delete this.filters[x];
                        return true;
                }
        }
        return false;
}, removeAllFilters:function () {
        this.filters = [];
}, filter:function (rec) {
        for (var x = 0; x < this.filters.length; x++) {
                if ((this.filters[x]["filter"]) && (!this.filters[x].filter(rec)) || (rec.level < this.cutOffLevel)) {
                        return false;
                }
        }
        return true;
}, addHandler:function (hdlr) {
        this.handlers.push(hdlr);
        return this.handlers.length - 1;
}, handle:function (rec) {
        if ((!this.filter(rec)) || (rec.level < this.cutOffLevel)) {
                return false;
        }
        for (var x = 0; x < this.handlers.length; x++) {
                if (this.handlers[x]["handle"]) {
                        this.handlers[x].handle(rec);
                }
        }
        return true;
}, log:function (lvl, msg) {
        if ((this.propagate) && (this.parent) && (this.parent.rec.level >= this.cutOffLevel)) {
                this.parent.log(lvl, msg);
                return false;
        }
        this.handle(new dojo.logging.Record(lvl, msg));
        return true;
}, debug:function (msg) {
        return this.logType("DEBUG", this._argsToArr(arguments));
}, info:function (msg) {
        return this.logType("INFO", this._argsToArr(arguments));
}, warning:function (msg) {
        return this.logType("WARNING", this._argsToArr(arguments));
}, error:function (msg) {
        return this.logType("ERROR", this._argsToArr(arguments));
}, critical:function (msg) {
        return this.logType("CRITICAL", this._argsToArr(arguments));
}, exception:function (msg, e, squelch) {
        if (e) {
                var eparts = [e.name, (e.description || e.message)];
                if (e.fileName) {
                        eparts.push(e.fileName);
                        eparts.push("line " + e.lineNumber);
                }
                msg += " " + eparts.join(" : ");
        }
        this.logType("ERROR", msg);
        if (!squelch) {
                throw e;
        }
}, logType:function (type, args) {
        return this.log.apply(this, [dojo.logging.log.getLevel(type), args]);
}, warn:function () {
        this.warning.apply(this, arguments);
}, err:function () {
        this.error.apply(this, arguments);
}, crit:function () {
        this.critical.apply(this, arguments);
}});
dojo.logging.LogHandler = function (level) {
        this.cutOffLevel = (level) ? level : 0;
        this.formatter = null;
        this.data = [];
        this.filters = [];
};
dojo.lang.extend(dojo.logging.LogHandler, {setFormatter:function (formatter) {
        dojo.unimplemented("setFormatter");
}, flush:function () {
}, close:function () {
}, handleError:function () {
        dojo.deprecated("dojo.logging.LogHandler.handleError", "use handle()", "0.6");
}, handle:function (record) {
        if ((this.filter(record)) && (record.level >= this.cutOffLevel)) {
                this.emit(record);
        }
}, emit:function (record) {
        dojo.unimplemented("emit");
}});
void (function () {
        var names = ["setLevel", "addFilter", "removeFilterByIndex", "removeFilter", "removeAllFilters", "filter"];
        var tgt = dojo.logging.LogHandler.prototype;
        var src = dojo.logging.Logger.prototype;
        for (var x = 0; x < names.length; x++) {
                tgt[names[x]] = src[names[x]];
        }
})();
dojo.logging.log = new dojo.logging.Logger();
dojo.logging.log.levels = [{"name":"DEBUG", "level":1}, {"name":"INFO", "level":2}, {"name":"WARNING", "level":3}, {"name":"ERROR", "level":4}, {"name":"CRITICAL", "level":5}];
dojo.logging.log.loggers = {};
dojo.logging.log.getLogger = function (name) {
        if (!this.loggers[name]) {
                this.loggers[name] = new dojo.logging.Logger();
                this.loggers[name].parent = this;
        }
        return this.loggers[name];
};
dojo.logging.log.getLevelName = function (lvl) {
        for (var x = 0; x < this.levels.length; x++) {
                if (this.levels[x].level == lvl) {
                        return this.levels[x].name;
                }
        }
        return null;
};
dojo.logging.log.getLevel = function (name) {
        for (var x = 0; x < this.levels.length; x++) {
                if (this.levels[x].name.toUpperCase() == name.toUpperCase()) {
                        return this.levels[x].level;
                }
        }
        return null;
};
dojo.declare("dojo.logging.MemoryLogHandler", dojo.logging.LogHandler, {initializer:function (level, recordsToKeep, postType, postInterval) {
        dojo.logging.LogHandler.call(this, level);
        this.numRecords = (typeof djConfig["loggingNumRecords"] != "undefined") ? djConfig["loggingNumRecords"] : ((recordsToKeep) ? recordsToKeep : -1);
        this.postType = (typeof djConfig["loggingPostType"] != "undefined") ? djConfig["loggingPostType"] : (postType || -1);
        this.postInterval = (typeof djConfig["loggingPostInterval"] != "undefined") ? djConfig["loggingPostInterval"] : (postType || -1);
}, emit:function (record) {
        if (!djConfig.isDebug) {
                return;
        }
        var logStr = String(dojo.log.getLevelName(record.level) + ": " + record.time.toLocaleTimeString()) + ": " + record.message;
        if (!dj_undef("println", dojo.hostenv)) {
                dojo.hostenv.println(logStr, record.msgArgs);
        }
        this.data.push(record);
        if (this.numRecords != -1) {
                while (this.data.length > this.numRecords) {
                        this.data.shift();
                }
        }
}});
dojo.logging.logQueueHandler = new dojo.logging.MemoryLogHandler(0, 50, 0, 10000);
dojo.logging.log.addHandler(dojo.logging.logQueueHandler);
dojo.log = dojo.logging.log;