webclient.js-ext.yui.build.logger.logger.js Maven / Gradle / Ivy
/*
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:
*
* - category
* - label
* - sourceAndDetail
* - message
* - localTime
* - elapsedTime
* - totalTime
*
*
* @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