Mercurial > kallithea
view rhodecode/public/js/yui/logger/logger-debug.js @ 547:1e757ac98988
renamed project to rhodecode
author | Marcin Kuzminski <marcin@python-works.com> |
---|---|
date | Wed, 06 Oct 2010 03:18:16 +0200 |
parents | pylons_app/public/js/yui/logger/logger-debug.js@564e40829f80 |
children | 289ff43cc190 |
line wrap: on
line source
/* Copyright (c) 2009, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.net/yui/license.txt version: 2.8.0r4 */ /****************************************************************************/ /****************************************************************************/ /****************************************************************************/ /** * The LogMsg class defines a single log message. * * @class LogMsg * @constructor * @param oConfigs {Object} Object literal of configuration params. */ YAHOO.widget.LogMsg = function(oConfigs) { // Parse configs /** * Log message. * * @property msg * @type String */ this.msg = /** * Log timestamp. * * @property time * @type Date */ this.time = /** * Log category. * * @property category * @type String */ this.category = /** * Log source. The first word passed in as the source argument. * * @property source * @type String */ this.source = /** * Log source detail. The remainder of the string passed in as the source argument, not * including the first word (if any). * * @property sourceDetail * @type String */ this.sourceDetail = null; if (oConfigs && (oConfigs.constructor == Object)) { for(var param in oConfigs) { if (oConfigs.hasOwnProperty(param)) { this[param] = oConfigs[param]; } } } }; /****************************************************************************/ /****************************************************************************/ /****************************************************************************/ /** * The LogWriter class provides a mechanism to log messages through * YAHOO.widget.Logger from a named source. * * @class LogWriter * @constructor * @param sSource {String} Source of LogWriter instance. */ YAHOO.widget.LogWriter = function(sSource) { if(!sSource) { YAHOO.log("Could not instantiate LogWriter due to invalid source.", "error", "LogWriter"); return; } this._source = sSource; }; ///////////////////////////////////////////////////////////////////////////// // // Public methods // ///////////////////////////////////////////////////////////////////////////// /** * Public accessor to the unique name of the LogWriter instance. * * @method toString * @return {String} Unique name of the LogWriter instance. */ YAHOO.widget.LogWriter.prototype.toString = function() { return "LogWriter " + this._sSource; }; /** * Logs a message attached to the source of the LogWriter. * * @method log * @param sMsg {String} The log message. * @param sCategory {String} Category name. */ YAHOO.widget.LogWriter.prototype.log = function(sMsg, sCategory) { YAHOO.widget.Logger.log(sMsg, sCategory, this._source); }; /** * Public accessor to get the source name. * * @method getSource * @return {String} The LogWriter source. */ YAHOO.widget.LogWriter.prototype.getSource = function() { return this._source; }; /** * Public accessor to set the source name. * * @method setSource * @param sSource {String} Source of LogWriter instance. */ YAHOO.widget.LogWriter.prototype.setSource = function(sSource) { if(!sSource) { YAHOO.log("Could not set source due to invalid source.", "error", this.toString()); return; } else { this._source = sSource; } }; ///////////////////////////////////////////////////////////////////////////// // // Private member variables // ///////////////////////////////////////////////////////////////////////////// /** * Source of the LogWriter instance. * * @property _source * @type String * @private */ YAHOO.widget.LogWriter.prototype._source = null; /** * The Logger widget provides a simple way to read or write log messages in * JavaScript code. Integration with the YUI Library's debug builds allow * implementers to access under-the-hood events, errors, and debugging messages. * Output may be read through a LogReader console and/or output to a browser * console. * * @module logger * @requires yahoo, event, dom * @optional dragdrop * @namespace YAHOO.widget * @title Logger Widget */ /****************************************************************************/ /****************************************************************************/ /****************************************************************************/ // Define once if(!YAHOO.widget.Logger) { /** * The singleton Logger class provides core log management functionality. Saves * logs written through the global YAHOO.log function or written by a LogWriter * instance. Provides access to logs for reading by a LogReader instance or * native browser console such as the Firebug extension to Firefox or Safari's * JavaScript console through integration with the console.log() method. * * @class Logger * @static */ YAHOO.widget.Logger = { // Initialize properties loggerEnabled: true, _browserConsoleEnabled: false, categories: ["info","warn","error","time","window"], sources: ["global"], _stack: [], // holds all log msgs maxStackEntries: 2500, _startTime: new Date().getTime(), // static start timestamp _lastTime: null, // timestamp of last logged message _windowErrorsHandled: false, _origOnWindowError: null }; ///////////////////////////////////////////////////////////////////////////// // // Public properties // ///////////////////////////////////////////////////////////////////////////// /** * True if Logger is enabled, false otherwise. * * @property loggerEnabled * @type Boolean * @static * @default true */ /** * Array of categories. * * @property categories * @type String[] * @static * @default ["info","warn","error","time","window"] */ /** * Array of sources. * * @property sources * @type String[] * @static * @default ["global"] */ /** * Upper limit on size of internal stack. * * @property maxStackEntries * @type Number * @static * @default 2500 */ ///////////////////////////////////////////////////////////////////////////// // // Private properties // ///////////////////////////////////////////////////////////////////////////// /** * Internal property to track whether output to browser console is enabled. * * @property _browserConsoleEnabled * @type Boolean * @static * @default false * @private */ /** * Array to hold all log messages. * * @property _stack * @type Array * @static * @private */ /** * Static timestamp of Logger initialization. * * @property _startTime * @type Date * @static * @private */ /** * Timestamp of last logged message. * * @property _lastTime * @type Date * @static * @private */ ///////////////////////////////////////////////////////////////////////////// // // Public methods // ///////////////////////////////////////////////////////////////////////////// /** * Saves a log message to the stack and fires newLogEvent. If the log message is * assigned to an unknown category, creates a new category. If the log message is * from an unknown source, creates a new source. If browser console is enabled, * outputs the log message to browser console. * * @method log * @param sMsg {String} The log message. * @param sCategory {String} Category of log message, or null. * @param sSource {String} Source of LogWriter, or null if global. */ YAHOO.widget.Logger.log = function(sMsg, sCategory, sSource) { if(this.loggerEnabled) { if(!sCategory) { sCategory = "info"; // default category } else { sCategory = sCategory.toLocaleLowerCase(); if(this._isNewCategory(sCategory)) { this._createNewCategory(sCategory); } } var sClass = "global"; // default source var sDetail = null; if(sSource) { var spaceIndex = sSource.indexOf(" "); if(spaceIndex > 0) { // Substring until first space sClass = sSource.substring(0,spaceIndex); // The rest of the source sDetail = sSource.substring(spaceIndex,sSource.length); } else { sClass = sSource; } if(this._isNewSource(sClass)) { this._createNewSource(sClass); } } var timestamp = new Date(); var logEntry = new YAHOO.widget.LogMsg({ msg: sMsg, time: timestamp, category: sCategory, source: sClass, sourceDetail: sDetail }); var stack = this._stack; var maxStackEntries = this.maxStackEntries; if(maxStackEntries && !isNaN(maxStackEntries) && (stack.length >= maxStackEntries)) { stack.shift(); } stack.push(logEntry); this.newLogEvent.fire(logEntry); if(this._browserConsoleEnabled) { this._printToBrowserConsole(logEntry); } return true; } else { return false; } }; /** * Resets internal stack and startTime, enables Logger, and fires logResetEvent. * * @method reset */ YAHOO.widget.Logger.reset = function() { this._stack = []; this._startTime = new Date().getTime(); this.loggerEnabled = true; this.log("Logger reset"); this.logResetEvent.fire(); }; /** * Public accessor to internal stack of log message objects. * * @method getStack * @return {Object[]} Array of log message objects. */ YAHOO.widget.Logger.getStack = function() { return this._stack; }; /** * Public accessor to internal start time. * * @method getStartTime * @return {Date} Internal date of when Logger singleton was initialized. */ YAHOO.widget.Logger.getStartTime = function() { return this._startTime; }; /** * Disables output to the browser's global console.log() function, which is used * by the Firebug extension to Firefox as well as Safari. * * @method disableBrowserConsole */ YAHOO.widget.Logger.disableBrowserConsole = function() { YAHOO.log("Logger output to the function console.log() has been disabled."); this._browserConsoleEnabled = false; }; /** * Enables output to the browser's global console.log() function, which is used * by the Firebug extension to Firefox as well as Safari. * * @method enableBrowserConsole */ YAHOO.widget.Logger.enableBrowserConsole = function() { this._browserConsoleEnabled = true; YAHOO.log("Logger output to the function console.log() has been enabled."); }; /** * Surpresses native JavaScript errors and outputs to console. By default, * Logger does not handle JavaScript window error events. * NB: Not all browsers support the window.onerror event. * * @method handleWindowErrors */ YAHOO.widget.Logger.handleWindowErrors = function() { if(!YAHOO.widget.Logger._windowErrorsHandled) { // Save any previously defined handler to call if(window.error) { YAHOO.widget.Logger._origOnWindowError = window.onerror; } window.onerror = YAHOO.widget.Logger._onWindowError; YAHOO.widget.Logger._windowErrorsHandled = true; YAHOO.log("Logger handling of window.onerror has been enabled."); } else { YAHOO.log("Logger handling of window.onerror had already been enabled."); } }; /** * Unsurpresses native JavaScript errors. By default, * Logger does not handle JavaScript window error events. * NB: Not all browsers support the window.onerror event. * * @method unhandleWindowErrors */ YAHOO.widget.Logger.unhandleWindowErrors = function() { if(YAHOO.widget.Logger._windowErrorsHandled) { // Revert to any previously defined handler to call if(YAHOO.widget.Logger._origOnWindowError) { window.onerror = YAHOO.widget.Logger._origOnWindowError; YAHOO.widget.Logger._origOnWindowError = null; } else { window.onerror = null; } YAHOO.widget.Logger._windowErrorsHandled = false; YAHOO.log("Logger handling of window.onerror has been disabled."); } else { YAHOO.log("Logger handling of window.onerror had already been disabled."); } }; ///////////////////////////////////////////////////////////////////////////// // // Public events // ///////////////////////////////////////////////////////////////////////////// /** * Fired when a new category has been created. * * @event categoryCreateEvent * @param sCategory {String} Category name. */ YAHOO.widget.Logger.categoryCreateEvent = new YAHOO.util.CustomEvent("categoryCreate", this, true); /** * Fired when a new source has been named. * * @event sourceCreateEvent * @param sSource {String} Source name. */ YAHOO.widget.Logger.sourceCreateEvent = new YAHOO.util.CustomEvent("sourceCreate", this, true); /** * Fired when a new log message has been created. * * @event newLogEvent * @param sMsg {String} Log message. */ YAHOO.widget.Logger.newLogEvent = new YAHOO.util.CustomEvent("newLog", this, true); /** * Fired when the Logger has been reset has been created. * * @event logResetEvent */ YAHOO.widget.Logger.logResetEvent = new YAHOO.util.CustomEvent("logReset", this, true); ///////////////////////////////////////////////////////////////////////////// // // Private methods // ///////////////////////////////////////////////////////////////////////////// /** * Creates a new category of log messages and fires categoryCreateEvent. * * @method _createNewCategory * @param sCategory {String} Category name. * @private */ YAHOO.widget.Logger._createNewCategory = function(sCategory) { this.categories.push(sCategory); this.categoryCreateEvent.fire(sCategory); }; /** * Checks to see if a category has already been created. * * @method _isNewCategory * @param sCategory {String} Category name. * @return {Boolean} Returns true if category is unknown, else returns false. * @private */ YAHOO.widget.Logger._isNewCategory = function(sCategory) { for(var i=0; i < this.categories.length; i++) { if(sCategory == this.categories[i]) { return false; } } return true; }; /** * Creates a new source of log messages and fires sourceCreateEvent. * * @method _createNewSource * @param sSource {String} Source name. * @private */ YAHOO.widget.Logger._createNewSource = function(sSource) { this.sources.push(sSource); this.sourceCreateEvent.fire(sSource); }; /** * Checks to see if a source already exists. * * @method _isNewSource * @param sSource {String} Source name. * @return {Boolean} Returns true if source is unknown, else returns false. * @private */ YAHOO.widget.Logger._isNewSource = function(sSource) { if(sSource) { for(var i=0; i < this.sources.length; i++) { if(sSource == this.sources[i]) { return false; } } return true; } }; /** * Outputs a log message to global console.log() function. * * @method _printToBrowserConsole * @param oEntry {Object} Log entry object. * @private */ YAHOO.widget.Logger._printToBrowserConsole = function(oEntry) { if(window.console && console.log) { var category = oEntry.category; var label = oEntry.category.substring(0,4).toUpperCase(); var time = oEntry.time; var localTime; if (time.toLocaleTimeString) { localTime = time.toLocaleTimeString(); } else { localTime = time.toString(); } var msecs = time.getTime(); var elapsedTime = (YAHOO.widget.Logger._lastTime) ? (msecs - YAHOO.widget.Logger._lastTime) : 0; YAHOO.widget.Logger._lastTime = msecs; var output = localTime + " (" + elapsedTime + "ms): " + oEntry.source + ": "; // for bug 1987607 if (YAHOO.env.ua.webkit) { output += oEntry.msg; } console.log(output, oEntry.msg); } }; ///////////////////////////////////////////////////////////////////////////// // // Private event handlers // ///////////////////////////////////////////////////////////////////////////// /** * Handles logging of messages due to window error events. * * @method _onWindowError * @param sMsg {String} The error message. * @param sUrl {String} URL of the error. * @param sLine {String} Line number of the error. * @private */ YAHOO.widget.Logger._onWindowError = function(sMsg,sUrl,sLine) { // Logger is not in scope of this event handler try { YAHOO.widget.Logger.log(sMsg+' ('+sUrl+', line '+sLine+')', "window"); if(YAHOO.widget.Logger._origOnWindowError) { YAHOO.widget.Logger._origOnWindowError(); } } catch(e) { return false; } }; ///////////////////////////////////////////////////////////////////////////// // // First log // ///////////////////////////////////////////////////////////////////////////// YAHOO.widget.Logger.log("Logger initialized"); } /****************************************************************************/ /****************************************************************************/ /****************************************************************************/ (function () { var Logger = YAHOO.widget.Logger, u = YAHOO.util, Dom = u.Dom, Event = u.Event, d = document; function make(el,props) { el = d.createElement(el); if (props) { for (var p in props) { if (props.hasOwnProperty(p)) { el[p] = props[p]; } } } return el; } /** * The LogReader class provides UI to read messages logged to YAHOO.widget.Logger. * * @class LogReader * @constructor * @param elContainer {HTMLElement} (optional) DOM element reference of an existing DIV. * @param elContainer {String} (optional) String ID of an existing DIV. * @param oConfigs {Object} (optional) Object literal of configuration params. */ function LogReader(elContainer, oConfigs) { this._sName = LogReader._index; LogReader._index++; this._init.apply(this,arguments); /** * Render the LogReader immediately upon instantiation. If set to false, * you must call myLogReader.render() to generate the UI. * * @property autoRender * @type {Boolean} * @default true */ if (this.autoRender !== false) { this.render(); } } ///////////////////////////////////////////////////////////////////////////// // // Static member variables // ///////////////////////////////////////////////////////////////////////////// YAHOO.lang.augmentObject(LogReader, { /** * Internal class member to index multiple LogReader instances. * * @property _memberName * @static * @type Number * @default 0 * @private */ _index : 0, /** * Node template for the log entries * @property ENTRY_TEMPLATE * @static * @type {HTMLElement} * @default <code>pre</code> element with class yui-log-entry */ ENTRY_TEMPLATE : (function () { return make('pre',{ className: 'yui-log-entry' }); })(), /** * Template used for innerHTML of verbose entry output. * @property VERBOSE_TEMPLATE * @static * @default "<p><span class='{category}'>{label}</span>{totalTime}ms (+{elapsedTime}) {localTime}:</p><p>{sourceAndDetail}</p><p>{message}</p>" */ VERBOSE_TEMPLATE : "<p><span class='{category}'>{label}</span> {totalTime}ms (+{elapsedTime}) {localTime}:</p><p>{sourceAndDetail}</p><p>{message}</p>", /** * Template used for innerHTML of compact entry output. * @property BASIC_TEMPLATE * @static * @default "<p><span class='{category}'>{label}</span>{totalTime}ms (+{elapsedTime}) {localTime}: {sourceAndDetail}: {message}</p>" */ BASIC_TEMPLATE : "<p><span class='{category}'>{label}</span> {totalTime}ms (+{elapsedTime}) {localTime}: {sourceAndDetail}: {message}</p>" }); ///////////////////////////////////////////////////////////////////////////// // // Public member variables // ///////////////////////////////////////////////////////////////////////////// LogReader.prototype = { /** * Whether or not LogReader is enabled to output log messages. * * @property logReaderEnabled * @type Boolean * @default true */ logReaderEnabled : true, /** * Public member to access CSS width of the LogReader container. * * @property width * @type String */ width : null, /** * Public member to access CSS height of the LogReader container. * * @property height * @type String */ height : null, /** * Public member to access CSS top position of the LogReader container. * * @property top * @type String */ top : null, /** * Public member to access CSS left position of the LogReader container. * * @property left * @type String */ left : null, /** * Public member to access CSS right position of the LogReader container. * * @property right * @type String */ right : null, /** * Public member to access CSS bottom position of the LogReader container. * * @property bottom * @type String */ bottom : null, /** * Public member to access CSS font size of the LogReader container. * * @property fontSize * @type String */ fontSize : null, /** * Whether or not the footer UI is enabled for the LogReader. * * @property footerEnabled * @type Boolean * @default true */ footerEnabled : true, /** * Whether or not output is verbose (more readable). Setting to true will make * output more compact (less readable). * * @property verboseOutput * @type Boolean * @default true */ verboseOutput : true, /** * Custom output format for log messages. Defaults to null, which falls * back to verboseOutput param deciding between LogReader.VERBOSE_TEMPLATE * and LogReader.BASIC_TEMPLATE. Use bracketed place holders to mark where * message info should go. Available place holder names include: * <ul> * <li>category</li> * <li>label</li> * <li>sourceAndDetail</li> * <li>message</li> * <li>localTime</li> * <li>elapsedTime</li> * <li>totalTime</li> * </ul> * * @property entryFormat * @type String * @default null */ entryFormat : null, /** * Whether or not newest message is printed on top. * * @property newestOnTop * @type Boolean */ newestOnTop : true, /** * Output timeout buffer in milliseconds. * * @property outputBuffer * @type Number * @default 100 */ outputBuffer : 100, /** * Maximum number of messages a LogReader console will display. * * @property thresholdMax * @type Number * @default 500 */ thresholdMax : 500, /** * When a LogReader console reaches its thresholdMax, it will clear out messages * and print out the latest thresholdMin number of messages. * * @property thresholdMin * @type Number * @default 100 */ thresholdMin : 100, /** * True when LogReader is in a collapsed state, false otherwise. * * @property isCollapsed * @type Boolean * @default false */ isCollapsed : false, /** * True when LogReader is in a paused state, false otherwise. * * @property isPaused * @type Boolean * @default false */ isPaused : false, /** * Enables draggable LogReader if DragDrop Utility is present. * * @property draggable * @type Boolean * @default true */ draggable : true, ///////////////////////////////////////////////////////////////////////////// // // Public methods // ///////////////////////////////////////////////////////////////////////////// /** * Public accessor to the unique name of the LogReader instance. * * @method toString * @return {String} Unique name of the LogReader instance. */ toString : function() { return "LogReader instance" + this._sName; }, /** * Pauses output of log messages. While paused, log messages are not lost, but * get saved to a buffer and then output upon resume of LogReader. * * @method pause */ pause : function() { this.isPaused = true; this._timeout = null; this.logReaderEnabled = false; if (this._btnPause) { this._btnPause.value = "Resume"; } }, /** * Resumes output of log messages, including outputting any log messages that * have been saved to buffer while paused. * * @method resume */ resume : function() { this.isPaused = false; this.logReaderEnabled = true; this._printBuffer(); if (this._btnPause) { this._btnPause.value = "Pause"; } }, /** * Adds the UI to the DOM, attaches event listeners, and bootstraps initial * UI state. * * @method render */ render : function () { if (this.rendered) { return; } this._initContainerEl(); this._initHeaderEl(); this._initConsoleEl(); this._initFooterEl(); this._initCategories(); this._initSources(); this._initDragDrop(); // Subscribe to Logger custom events Logger.newLogEvent.subscribe(this._onNewLog, this); Logger.logResetEvent.subscribe(this._onReset, this); Logger.categoryCreateEvent.subscribe(this._onCategoryCreate, this); Logger.sourceCreateEvent.subscribe(this._onSourceCreate, this); this.rendered = true; this._filterLogs(); }, /** * Removes the UI from the DOM entirely and detaches all event listeners. * Implementers should note that Logger will still accumulate messages. * * @method destroy */ destroy : function () { Event.purgeElement(this._elContainer,true); this._elContainer.innerHTML = ''; this._elContainer.parentNode.removeChild(this._elContainer); this.rendered = false; }, /** * Hides UI of LogReader. Logging functionality is not disrupted. * * @method hide */ hide : function() { this._elContainer.style.display = "none"; }, /** * Shows UI of LogReader. Logging functionality is not disrupted. * * @method show */ show : function() { this._elContainer.style.display = "block"; }, /** * Collapses UI of LogReader. Logging functionality is not disrupted. * * @method collapse */ collapse : function() { this._elConsole.style.display = "none"; if(this._elFt) { this._elFt.style.display = "none"; } this._btnCollapse.value = "Expand"; this.isCollapsed = true; }, /** * Expands UI of LogReader. Logging functionality is not disrupted. * * @method expand */ expand : function() { this._elConsole.style.display = "block"; if(this._elFt) { this._elFt.style.display = "block"; } this._btnCollapse.value = "Collapse"; this.isCollapsed = false; }, /** * Returns related checkbox element for given filter (i.e., category or source). * * @method getCheckbox * @param {String} Category or source name. * @return {Array} Array of all filter checkboxes. */ getCheckbox : function(filter) { return this._filterCheckboxes[filter]; }, /** * Returns array of enabled categories. * * @method getCategories * @return {String[]} Array of enabled categories. */ getCategories : function() { return this._categoryFilters; }, /** * Shows log messages associated with given category. * * @method showCategory * @param {String} Category name. */ showCategory : function(sCategory) { var filtersArray = this._categoryFilters; // Don't do anything if category is already enabled // Use Array.indexOf if available... if(filtersArray.indexOf) { if(filtersArray.indexOf(sCategory) > -1) { return; } } // ...or do it the old-fashioned way else { for(var i=0; i<filtersArray.length; i++) { if(filtersArray[i] === sCategory){ return; } } } this._categoryFilters.push(sCategory); this._filterLogs(); var elCheckbox = this.getCheckbox(sCategory); if(elCheckbox) { elCheckbox.checked = true; } }, /** * Hides log messages associated with given category. * * @method hideCategory * @param {String} Category name. */ hideCategory : function(sCategory) { var filtersArray = this._categoryFilters; for(var i=0; i<filtersArray.length; i++) { if(sCategory == filtersArray[i]) { filtersArray.splice(i, 1); break; } } this._filterLogs(); var elCheckbox = this.getCheckbox(sCategory); if(elCheckbox) { elCheckbox.checked = false; } }, /** * Returns array of enabled sources. * * @method getSources * @return {Array} Array of enabled sources. */ getSources : function() { return this._sourceFilters; }, /** * Shows log messages associated with given source. * * @method showSource * @param {String} Source name. */ showSource : function(sSource) { var filtersArray = this._sourceFilters; // Don't do anything if category is already enabled // Use Array.indexOf if available... if(filtersArray.indexOf) { if(filtersArray.indexOf(sSource) > -1) { return; } } // ...or do it the old-fashioned way else { for(var i=0; i<filtersArray.length; i++) { if(sSource == filtersArray[i]){ return; } } } filtersArray.push(sSource); this._filterLogs(); var elCheckbox = this.getCheckbox(sSource); if(elCheckbox) { elCheckbox.checked = true; } }, /** * Hides log messages associated with given source. * * @method hideSource * @param {String} Source name. */ hideSource : function(sSource) { var filtersArray = this._sourceFilters; for(var i=0; i<filtersArray.length; i++) { if(sSource == filtersArray[i]) { filtersArray.splice(i, 1); break; } } this._filterLogs(); var elCheckbox = this.getCheckbox(sSource); if(elCheckbox) { elCheckbox.checked = false; } }, /** * Does not delete any log messages, but clears all printed log messages from * the console. Log messages will be printed out again if user re-filters. The * static method YAHOO.widget.Logger.reset() should be called in order to * actually delete log messages. * * @method clearConsole */ clearConsole : function() { // Clear the buffer of any pending messages this._timeout = null; this._buffer = []; this._consoleMsgCount = 0; var elConsole = this._elConsole; elConsole.innerHTML = ''; }, /** * Updates title to given string. * * @method setTitle * @param sTitle {String} New title. */ setTitle : function(sTitle) { this._title.innerHTML = this.html2Text(sTitle); }, /** * Gets timestamp of the last log. * * @method getLastTime * @return {Date} Timestamp of the last log. */ getLastTime : function() { return this._lastTime; }, formatMsg : function (entry) { var entryFormat = this.entryFormat || (this.verboseOutput ? LogReader.VERBOSE_TEMPLATE : LogReader.BASIC_TEMPLATE), info = { category : entry.category, // Label for color-coded display label : entry.category.substring(0,4).toUpperCase(), sourceAndDetail : entry.sourceDetail ? entry.source + " " + entry.sourceDetail : entry.source, // Escape HTML entities in the log message itself for output // to console message : this.html2Text(entry.msg || entry.message || '') }; // Add time info if (entry.time && entry.time.getTime) { info.localTime = entry.time.toLocaleTimeString ? entry.time.toLocaleTimeString() : entry.time.toString(); // Calculate the elapsed time to be from the last item that // passed through the filter, not the absolute previous item // in the stack info.elapsedTime = entry.time.getTime() - this.getLastTime(); info.totalTime = entry.time.getTime() - Logger.getStartTime(); } var msg = LogReader.ENTRY_TEMPLATE.cloneNode(true); if (this.verboseOutput) { msg.className += ' yui-log-verbose'; } // Bug 2061169: Workaround for YAHOO.lang.substitute() msg.innerHTML = entryFormat.replace(/\{(\w+)\}/g, function (x, placeholder) { return (placeholder in info) ? info[placeholder] : ''; }); return msg; }, /** * Converts input chars "<", ">", and "&" to HTML entities. * * @method html2Text * @param sHtml {String} String to convert. * @private */ html2Text : function(sHtml) { if(sHtml) { sHtml += ""; return sHtml.replace(/&/g, "&"). replace(/</g, "<"). replace(/>/g, ">"); } return ""; }, ///////////////////////////////////////////////////////////////////////////// // // Private member variables // ///////////////////////////////////////////////////////////////////////////// /** * Name of LogReader instance. * * @property _sName * @type String * @private */ _sName : null, //TODO: remove /** * A class member shared by all LogReaders if a container needs to be * created during instantiation. Will be null if a container element never needs to * be created on the fly, such as when the implementer passes in their own element. * * @property _elDefaultContainer * @type HTMLElement * @private */ //YAHOO.widget.LogReader._elDefaultContainer = null; /** * Buffer of log message objects for batch output. * * @property _buffer * @type Object[] * @private */ _buffer : null, /** * Number of log messages output to console. * * @property _consoleMsgCount * @type Number * @default 0 * @private */ _consoleMsgCount : 0, /** * Date of last output log message. * * @property _lastTime * @type Date * @private */ _lastTime : null, /** * Batched output timeout ID. * * @property _timeout * @type Number * @private */ _timeout : null, /** * Hash of filters and their related checkbox elements. * * @property _filterCheckboxes * @type Object * @private */ _filterCheckboxes : null, /** * Array of filters for log message categories. * * @property _categoryFilters * @type String[] * @private */ _categoryFilters : null, /** * Array of filters for log message sources. * * @property _sourceFilters * @type String[] * @private */ _sourceFilters : null, /** * LogReader container element. * * @property _elContainer * @type HTMLElement * @private */ _elContainer : null, /** * LogReader header element. * * @property _elHd * @type HTMLElement * @private */ _elHd : null, /** * LogReader collapse element. * * @property _elCollapse * @type HTMLElement * @private */ _elCollapse : null, /** * LogReader collapse button element. * * @property _btnCollapse * @type HTMLElement * @private */ _btnCollapse : null, /** * LogReader title header element. * * @property _title * @type HTMLElement * @private */ _title : null, /** * LogReader console element. * * @property _elConsole * @type HTMLElement * @private */ _elConsole : null, /** * LogReader footer element. * * @property _elFt * @type HTMLElement * @private */ _elFt : null, /** * LogReader buttons container element. * * @property _elBtns * @type HTMLElement * @private */ _elBtns : null, /** * Container element for LogReader category filter checkboxes. * * @property _elCategoryFilters * @type HTMLElement * @private */ _elCategoryFilters : null, /** * Container element for LogReader source filter checkboxes. * * @property _elSourceFilters * @type HTMLElement * @private */ _elSourceFilters : null, /** * LogReader pause button element. * * @property _btnPause * @type HTMLElement * @private */ _btnPause : null, /** * Clear button element. * * @property _btnClear * @type HTMLElement * @private */ _btnClear : null, ///////////////////////////////////////////////////////////////////////////// // // Private methods // ///////////////////////////////////////////////////////////////////////////// /** * Initializes the instance's message buffer, start time, etc * * @method _init * @param container {String|HTMLElement} (optional) the render target * @param config {Object} (optional) instance configuration * @protected */ _init : function (container, config) { // Internal vars this._buffer = []; // output buffer this._filterCheckboxes = {}; // pointers to checkboxes this._lastTime = Logger.getStartTime(); // timestamp of last log message to console // Parse config vars here if (config && (config.constructor == Object)) { for(var param in config) { if (config.hasOwnProperty(param)) { this[param] = config[param]; } } } this._elContainer = Dom.get(container); YAHOO.log("LogReader initialized", null, this.toString()); }, /** * Initializes the primary container element. * * @method _initContainerEl * @private */ _initContainerEl : function() { // Default the container if unset or not a div if(!this._elContainer || !/div$/i.test(this._elContainer.tagName)) { this._elContainer = d.body.insertBefore(make("div"),d.body.firstChild); // Only position absolutely if an in-DOM element is not supplied Dom.addClass(this._elContainer,"yui-log-container"); } Dom.addClass(this._elContainer,"yui-log"); // If implementer has provided container values, trust and set those var style = this._elContainer.style, styleProps = ['width','right','top','fontSize'], prop,i; for (i = styleProps.length - 1; i >= 0; --i) { prop = styleProps[i]; if (this[prop]){ style[prop] = this[prop]; } } if(this.left) { style.left = this.left; style.right = "auto"; } if(this.bottom) { style.bottom = this.bottom; style.top = "auto"; } // Opera needs a little prodding to reflow sometimes if (YAHOO.env.ua.opera) { d.body.style += ''; } }, /** * Initializes the header element. * * @method _initHeaderEl * @private */ _initHeaderEl : function() { // Destroy header if present if(this._elHd) { // Unhook DOM events Event.purgeElement(this._elHd, true); // Remove DOM elements this._elHd.innerHTML = ""; } // Create header // TODO: refactor this into an innerHTML this._elHd = make("div",{ id: 'yui-log-hd' + this._sName, className: "yui-log-hd" }); this._elCollapse = make("div",{ className: 'yui-log-btns' }); this._btnCollapse = make("input",{ type: 'button', className: 'yui-log-button', value: 'Collapse' }); Event.on(this._btnCollapse,'click',this._onClickCollapseBtn,this); this._title = make("h4",{ innerHTML : "Logger Console" }); this._elCollapse.appendChild(this._btnCollapse); this._elHd.appendChild(this._elCollapse); this._elHd.appendChild(this._title); this._elContainer.appendChild(this._elHd); }, /** * Initializes the console element. * * @method _initConsoleEl * @private */ _initConsoleEl : function() { // Destroy console if(this._elConsole) { // Unhook DOM events Event.purgeElement(this._elConsole, true); // Remove DOM elements this._elConsole.innerHTML = ""; } // Ceate console this._elConsole = make("div", { className: "yui-log-bd" }); // If implementer has provided console, trust and set those if(this.height) { this._elConsole.style.height = this.height; } this._elContainer.appendChild(this._elConsole); }, /** * Initializes the footer element. * * @method _initFooterEl * @private */ _initFooterEl : function() { // Don't create footer elements if footer is disabled if(this.footerEnabled) { // Destroy console if(this._elFt) { // Unhook DOM events Event.purgeElement(this._elFt, true); // Remove DOM elements this._elFt.innerHTML = ""; } // TODO: use innerHTML this._elFt = make("div",{ className: "yui-log-ft" }); this._elBtns = make("div", { className: "yui-log-btns" }); this._btnPause = make("input", { type: "button", className: "yui-log-button", value: "Pause" }); Event.on(this._btnPause,'click',this._onClickPauseBtn,this); this._btnClear = make("input", { type: "button", className: "yui-log-button", value: "Clear" }); Event.on(this._btnClear,'click',this._onClickClearBtn,this); this._elCategoryFilters = make("div", { className: "yui-log-categoryfilters" }); this._elSourceFilters = make("div", { className: "yui-log-sourcefilters" }); this._elBtns.appendChild(this._btnPause); this._elBtns.appendChild(this._btnClear); this._elFt.appendChild(this._elBtns); this._elFt.appendChild(this._elCategoryFilters); this._elFt.appendChild(this._elSourceFilters); this._elContainer.appendChild(this._elFt); } }, /** * Initializes Drag and Drop on the header element. * * @method _initDragDrop * @private */ _initDragDrop : function() { // If Drag and Drop utility is available... // ...and draggable is true... // ...then make the header draggable if(u.DD && this.draggable && this._elHd) { var ylog_dd = new u.DD(this._elContainer); ylog_dd.setHandleElId(this._elHd.id); //TODO: use class name this._elHd.style.cursor = "move"; } }, /** * Initializes category filters. * * @method _initCategories * @private */ _initCategories : function() { // Initialize category filters this._categoryFilters = []; var aInitialCategories = Logger.categories; for(var j=0; j < aInitialCategories.length; j++) { var sCategory = aInitialCategories[j]; // Add category to the internal array of filters this._categoryFilters.push(sCategory); // Add checkbox element if UI is enabled if(this._elCategoryFilters) { this._createCategoryCheckbox(sCategory); } } }, /** * Initializes source filters. * * @method _initSources * @private */ _initSources : function() { // Initialize source filters this._sourceFilters = []; var aInitialSources = Logger.sources; for(var j=0; j < aInitialSources.length; j++) { var sSource = aInitialSources[j]; // Add source to the internal array of filters this._sourceFilters.push(sSource); // Add checkbox element if UI is enabled if(this._elSourceFilters) { this._createSourceCheckbox(sSource); } } }, /** * Creates the UI for a category filter in the LogReader footer element. * * @method _createCategoryCheckbox * @param sCategory {String} Category name. * @private */ _createCategoryCheckbox : function(sCategory) { if(this._elFt) { var filter = make("span",{ className: "yui-log-filtergrp" }), check = make("input", { id: "yui-log-filter-" + sCategory + this._sName, className: "yui-log-filter-" + sCategory, type: "checkbox", category: sCategory }), label = make("label", { htmlFor: check.id, className: sCategory, innerHTML: sCategory }); // Subscribe to the click event Event.on(check,'click',this._onCheckCategory,this); this._filterCheckboxes[sCategory] = check; // Append el at the end so IE 5.5 can set "type" attribute // and THEN set checked property filter.appendChild(check); filter.appendChild(label); this._elCategoryFilters.appendChild(filter); check.checked = true; } }, /** * Creates a checkbox in the LogReader footer element to filter by source. * * @method _createSourceCheckbox * @param sSource {String} Source name. * @private */ _createSourceCheckbox : function(sSource) { if(this._elFt) { var filter = make("span",{ className: "yui-log-filtergrp" }), check = make("input", { id: "yui-log-filter-" + sSource + this._sName, className: "yui-log-filter-" + sSource, type: "checkbox", source: sSource }), label = make("label", { htmlFor: check.id, className: sSource, innerHTML: sSource }); // Subscribe to the click event Event.on(check,'click',this._onCheckSource,this); this._filterCheckboxes[sSource] = check; // Append el at the end so IE 5.5 can set "type" attribute // and THEN set checked property filter.appendChild(check); filter.appendChild(label); this._elSourceFilters.appendChild(filter); check.checked = true; } }, /** * Reprints all log messages in the stack through filters. * * @method _filterLogs * @private */ _filterLogs : function() { // Reprint stack with new filters if (this._elConsole !== null) { this.clearConsole(); this._printToConsole(Logger.getStack()); } }, /** * Sends buffer of log messages to output and clears buffer. * * @method _printBuffer * @private */ _printBuffer : function() { this._timeout = null; if(this._elConsole !== null) { var thresholdMax = this.thresholdMax; thresholdMax = (thresholdMax && !isNaN(thresholdMax)) ? thresholdMax : 500; if(this._consoleMsgCount < thresholdMax) { var entries = []; for (var i=0; i<this._buffer.length; i++) { entries[i] = this._buffer[i]; } this._buffer = []; this._printToConsole(entries); } else { this._filterLogs(); } if(!this.newestOnTop) { this._elConsole.scrollTop = this._elConsole.scrollHeight; } } }, /** * Cycles through an array of log messages, and outputs each one to the console * if its category has not been filtered out. * * @method _printToConsole * @param aEntries {Object[]} Array of LogMsg objects to output to console. * @private */ _printToConsole : function(aEntries) { // Manage the number of messages displayed in the console var entriesLen = aEntries.length, df = d.createDocumentFragment(), msgHTML = [], thresholdMin = this.thresholdMin, sourceFiltersLen = this._sourceFilters.length, categoryFiltersLen = this._categoryFilters.length, entriesStartIndex, i, j, msg, before; if(isNaN(thresholdMin) || (thresholdMin > this.thresholdMax)) { thresholdMin = 0; } entriesStartIndex = (entriesLen > thresholdMin) ? (entriesLen - thresholdMin) : 0; // Iterate through all log entries for(i=entriesStartIndex; i<entriesLen; i++) { // Print only the ones that filter through var okToPrint = false, okToFilterCats = false, entry = aEntries[i], source = entry.source, category = entry.category; for(j=0; j<sourceFiltersLen; j++) { if(source == this._sourceFilters[j]) { okToFilterCats = true; break; } } if(okToFilterCats) { for(j=0; j<categoryFiltersLen; j++) { if(category == this._categoryFilters[j]) { okToPrint = true; break; } } } if(okToPrint) { // Start from 0ms elapsed time if (this._consoleMsgCount === 0) { this._lastTime = entry.time.getTime(); } msg = this.formatMsg(entry); if (typeof msg === 'string') { msgHTML[msgHTML.length] = msg; } else { df.insertBefore(msg, this.newestOnTop ? df.firstChild || null : null); } this._consoleMsgCount++; this._lastTime = entry.time.getTime(); } } if (msgHTML.length) { msgHTML.splice(0,0,this._elConsole.innerHTML); this._elConsole.innerHTML = this.newestOnTop ? msgHTML.reverse().join('') : msgHTML.join(''); } else if (df.firstChild) { this._elConsole.insertBefore(df, this.newestOnTop ? this._elConsole.firstChild || null : null); } }, ///////////////////////////////////////////////////////////////////////////// // // Private event handlers // ///////////////////////////////////////////////////////////////////////////// /** * Handles Logger's categoryCreateEvent. * * @method _onCategoryCreate * @param sType {String} The event. * @param aArgs {Object[]} Data passed from event firer. * @param oSelf {Object} The LogReader instance. * @private */ _onCategoryCreate : function(sType, aArgs, oSelf) { var category = aArgs[0]; // Add category to the internal array of filters oSelf._categoryFilters.push(category); if(oSelf._elFt) { oSelf._createCategoryCheckbox(category); } }, /** * Handles Logger's sourceCreateEvent. * * @method _onSourceCreate * @param sType {String} The event. * @param aArgs {Object[]} Data passed from event firer. * @param oSelf {Object} The LogReader instance. * @private */ _onSourceCreate : function(sType, aArgs, oSelf) { var source = aArgs[0]; // Add source to the internal array of filters oSelf._sourceFilters.push(source); if(oSelf._elFt) { oSelf._createSourceCheckbox(source); } }, /** * Handles check events on the category filter checkboxes. * * @method _onCheckCategory * @param v {HTMLEvent} The click event. * @param oSelf {Object} The LogReader instance. * @private */ _onCheckCategory : function(v, oSelf) { var category = this.category; if(!this.checked) { oSelf.hideCategory(category); } else { oSelf.showCategory(category); } }, /** * Handles check events on the category filter checkboxes. * * @method _onCheckSource * @param v {HTMLEvent} The click event. * @param oSelf {Object} The LogReader instance. * @private */ _onCheckSource : function(v, oSelf) { var source = this.source; if(!this.checked) { oSelf.hideSource(source); } else { oSelf.showSource(source); } }, /** * Handles click events on the collapse button. * * @method _onClickCollapseBtn * @param v {HTMLEvent} The click event. * @param oSelf {Object} The LogReader instance * @private */ _onClickCollapseBtn : function(v, oSelf) { if(!oSelf.isCollapsed) { oSelf.collapse(); } else { oSelf.expand(); } }, /** * Handles click events on the pause button. * * @method _onClickPauseBtn * @param v {HTMLEvent} The click event. * @param oSelf {Object} The LogReader instance. * @private */ _onClickPauseBtn : function(v, oSelf) { if(!oSelf.isPaused) { oSelf.pause(); } else { oSelf.resume(); } }, /** * Handles click events on the clear button. * * @method _onClickClearBtn * @param v {HTMLEvent} The click event. * @param oSelf {Object} The LogReader instance. * @private */ _onClickClearBtn : function(v, oSelf) { oSelf.clearConsole(); }, /** * Handles Logger's newLogEvent. * * @method _onNewLog * @param sType {String} The event. * @param aArgs {Object[]} Data passed from event firer. * @param oSelf {Object} The LogReader instance. * @private */ _onNewLog : function(sType, aArgs, oSelf) { var logEntry = aArgs[0]; oSelf._buffer.push(logEntry); if (oSelf.logReaderEnabled === true && oSelf._timeout === null) { oSelf._timeout = setTimeout(function(){oSelf._printBuffer();}, oSelf.outputBuffer); } }, /** * Handles Logger's resetEvent. * * @method _onReset * @param sType {String} The event. * @param aArgs {Object[]} Data passed from event firer. * @param oSelf {Object} The LogReader instance. * @private */ _onReset : function(sType, aArgs, oSelf) { oSelf._filterLogs(); } }; YAHOO.widget.LogReader = LogReader; })(); YAHOO.register("logger", YAHOO.widget.Logger, {version: "2.8.0r4", build: "2449"});