/* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 2.8.2r1 */ /****************************************************************************/ /****************************************************************************/ /****************************************************************************/ /** * 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 pre 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 : "

{label} {totalTime}ms (+{elapsedTime}) {localTime}:

{sourceAndDetail}

{message}

", /** * 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 : "

{label} {totalTime}ms (+{elapsedTime}) {localTime}: {sourceAndDetail}: {message}

" }); ///////////////////////////////////////////////////////////////////////////// // // 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: * * * @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 -1) { return; } } // ...or do it the old-fashioned way else { for(var i=0; i", 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, ">"); } 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.thresholdMax)) { thresholdMin = 0; } entriesStartIndex = (entriesLen > thresholdMin) ? (entriesLen - thresholdMin) : 0; // Iterate through all log entries for(i=entriesStartIndex; i