/*
Copyright (c) 2007, Yahoo! Inc. All rights reserved.
Code licensed under the BSD License:
version: 2.3.0
*/
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
/**
* The LogMsg class defines a single log message.
*
* @class LogMsg
* @constructor
* @param oConfigs {Object} Object literal of configuration params.
*/
// Parse configs
}
}
};
/////////////////////////////////////////////////////////////////////////////
//
// Public member variables
//
/////////////////////////////////////////////////////////////////////////////
/**
* Log message.
*
* @property msg
* @type String
*/
/**
* Log timestamp.
*
* @property time
* @type Date
*/
/**
* Log category.
*
* @property category
* @type String
*/
/**
* Log source. The first word passed in as the source argument.
*
* @property source
* @type String
*/
/**
* 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
*/
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
/**
* 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.
*/
if(!sSource) {
"error", "LogWriter");
return;
}
};
/////////////////////////////////////////////////////////////////////////////
//
// Public methods
//
/////////////////////////////////////////////////////////////////////////////
/**
* Public accessor to the unique name of the LogWriter instance.
*
* @method toString
* @return {String} Unique name of the LogWriter instance.
*/
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.
*/
};
/**
* Public accessor to get the source name.
*
* @method getSource
* @return {String} The LogWriter source.
*/
return this._sSource;
};
/**
* Public accessor to set the source name.
*
* @method setSource
* @param sSource {String} Source of LogWriter instance.
*/
if(!sSource) {
return;
}
else {
}
};
/////////////////////////////////////////////////////////////////////////////
//
// Private member variables
//
/////////////////////////////////////////////////////////////////////////////
/**
* Source of the LogWriter instance.
*
* @property _source
* @type String
* @private
*/
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
/**
* 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.
*/
// Internal vars
this._buffer = []; // output buffer
this._filterCheckboxes = {}; // pointers to checkboxes
// Parse config vars here
}
}
this._initContainerEl(elContainer);
if(!this._elContainer) {
return;
}
this._initHeaderEl();
this._initConsoleEl();
this._initFooterEl();
this._initDragDrop();
this._initCategories();
this._initSources();
// Subscribe to Logger custom events
this._filterLogs();
};
/////////////////////////////////////////////////////////////////////////////
//
// Public member variables
//
/////////////////////////////////////////////////////////////////////////////
/**
* Whether or not LogReader is enabled to output log messages.
*
* @property logReaderEnabled
* @type Boolean
* @default true
*/
/**
* Public member to access CSS width of the LogReader container.
*
* @property width
* @type String
*/
/**
* Public member to access CSS height of the LogReader container.
*
* @property height
* @type String
*/
/**
* Public member to access CSS top position of the LogReader container.
*
* @property top
* @type String
*/
/**
* Public member to access CSS left position of the LogReader container.
*
* @property left
* @type String
*/
/**
* Public member to access CSS right position of the LogReader container.
*
* @property right
* @type String
*/
/**
* Public member to access CSS bottom position of the LogReader container.
*
* @property bottom
* @type String
*/
/**
* Public member to access CSS font size of the LogReader container.
*
* @property fontSize
* @type String
*/
/**
* Whether or not the footer UI is enabled for the LogReader.
*
* @property footerEnabled
* @type Boolean
* @default 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
*/
/**
* Whether or not newest message is printed on top.
*
* @property newestOnTop
* @type Boolean
*/
/**
* Output timeout buffer in milliseconds.
*
* @property outputBuffer
* @type Number
* @default 100
*/
/**
* Maximum number of messages a LogReader console will display.
*
* @property thresholdMax
* @type Number
* @default 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
*/
/**
* True when LogReader is in a collapsed state, false otherwise.
*
* @property isCollapsed
* @type Boolean
* @default false
*/
/**
* True when LogReader is in a paused state, false otherwise.
*
* @property isPaused
* @type Boolean
* @default false
*/
/**
* Enables draggable LogReader if DragDrop Utility is present.
*
* @property draggable
* @type Boolean
* @default true
*/
/////////////////////////////////////////////////////////////////////////////
//
// Public methods
//
/////////////////////////////////////////////////////////////////////////////
/**
* Public accessor to the unique name of the LogReader instance.
*
* @method toString
* @return {String} Unique name of the LogReader instance.
*/
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
*/
this.isPaused = true;
this._timeout = null;
this.logReaderEnabled = false;
};
/**
* Resumes output of log messages, including outputting any log messages that
* have been saved to buffer while paused.
*
* @method resume
*/
this.isPaused = false;
this.logReaderEnabled = true;
this._printBuffer();
};
/**
* Hides UI of LogReader. Logging functionality is not disrupted.
*
* @method hide
*/
};
/**
* Shows UI of LogReader. Logging functionality is not disrupted.
*
* @method show
*/
};
/**
* Collapses UI of LogReader. Logging functionality is not disrupted.
*
* @method collapse
*/
if(this._elFt) {
}
this.isCollapsed = true;
};
/**
* Expands UI of LogReader. Logging functionality is not disrupted.
*
* @method expand
*/
if(this._elFt) {
}
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.
*/
return this._filterCheckboxes[filter];
};
/**
* Returns array of enabled categories.
*
* @method getCategories
* @return {String[]} Array of enabled categories.
*/
return this._categoryFilters;
};
/**
* Shows log messages associated with given category.
*
* @method showCategory
* @param {String} Category name.
*/
var filtersArray = this._categoryFilters;
// Don't do anything if category is already enabled
// Use Array.indexOf if available...
if(filtersArray.indexOf) {
return;
}
}
// ...or do it the old-fashioned way
else {
if(filtersArray[i] === sCategory){
return;
}
}
}
this._filterLogs();
if(elCheckbox) {
elCheckbox.checked = true;
}
};
/**
* Hides log messages associated with given category.
*
* @method hideCategory
* @param {String} Category name.
*/
var filtersArray = this._categoryFilters;
if(sCategory == filtersArray[i]) {
break;
}
}
this._filterLogs();
if(elCheckbox) {
elCheckbox.checked = false;
}
};
/**
* Returns array of enabled sources.
*
* @method getSources
* @return {Array} Array of enabled sources.
*/
return this._sourceFilters;
};
/**
* Shows log messages associated with given source.
*
* @method showSource
* @param {String} Source name.
*/
var filtersArray = this._sourceFilters;
// Don't do anything if category is already enabled
// Use Array.indexOf if available...
if(filtersArray.indexOf) {
return;
}
}
// ...or do it the old-fashioned way
else {
if(sSource == filtersArray[i]){
return;
}
}
}
this._filterLogs();
if(elCheckbox) {
elCheckbox.checked = true;
}
};
/**
* Hides log messages associated with given source.
*
* @method hideSource
* @param {String} Source name.
*/
var filtersArray = this._sourceFilters;
if(sSource == filtersArray[i]) {
break;
}
}
this._filterLogs();
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
*/
// Clear the buffer of any pending messages
this._timeout = null;
this._buffer = [];
this._consoleMsgCount = 0;
var elConsole = this._elConsole;
while(elConsole.hasChildNodes()) {
}
};
/**
* Updates title to given string.
*
* @method setTitle
* @param sTitle {String} New title.
*/
};
/**
* Gets timestamp of the last log.
*
* @method getLastTime
* @return {Date} Timestamp of the last log.
*/
return this._lastTime;
};
/**
* Formats message string to HTML for output to console.
*
* @method formatMsg
* @param oLogMsg {Object} Log message object.
* @return {String} HTML-formatted message for output to console.
*/
// Label for color-coded display
// Calculate the elapsed time to be from the last item that passed through the filter,
// not the absolute previous item in the stack
if (time.toLocaleTimeString) {
}
else {
}
var sourceAndDetail = (sourceDetail) ?
// Escape HTML entities in the log message itself for output to console
//var msg = this.html2Text(oLogMsg.msg); //TODO: delete
// Verbose output includes extra line breaks
var output = (this.verboseOutput) ?
localTime, ": ",
"</p><p>",
": </p><p>",
msg,
"</p></pre>"] :
localTime, ": ",
sourceAndDetail, ": ",
msg, "</p></pre>"];
};
/**
* Converts input chars "<", ">", and "&" to HTML entities.
*
* @method html2Text
* @param sHtml {String} String to convert.
* @private
*/
if(sHtml) {
sHtml += "";
}
return "";
};
/////////////////////////////////////////////////////////////////////////////
//
// Private member variables
//
/////////////////////////////////////////////////////////////////////////////
/**
* Internal class member to index multiple LogReader instances.
*
* @property _memberName
* @static
* @type Number
* @default 0
* @private
*/
/**
* Name of LogReader instance.
*
* @property _sName
* @type String
* @private
*/
//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
*/
/**
* Number of log messages output to console.
*
* @property _consoleMsgCount
* @type Number
* @default 0
* @private
*/
/**
* Date of last output log message.
*
* @property _lastTime
* @type Date
* @private
*/
/**
* Batched output timeout ID.
*
* @property _timeout
* @type Number
* @private
*/
/**
* Hash of filters and their related checkbox elements.
*
* @property _filterCheckboxes
* @type Object
* @private
*/
/**
* Array of filters for log message categories.
*
* @property _categoryFilters
* @type String[]
* @private
*/
/**
* Array of filters for log message sources.
*
* @property _sourceFilters
* @type String[]
* @private
*/
/**
* LogReader container element.
*
* @property _elContainer
* @type HTMLElement
* @private
*/
/**
* LogReader header element.
*
* @property _elHd
* @type HTMLElement
* @private
*/
/**
* LogReader collapse element.
*
* @property _elCollapse
* @type HTMLElement
* @private
*/
/**
* LogReader collapse button element.
*
* @property _btnCollapse
* @type HTMLElement
* @private
*/
/**
* LogReader title header element.
*
* @property _title
* @type HTMLElement
* @private
*/
/**
* LogReader console element.
*
* @property _elConsole
* @type HTMLElement
* @private
*/
/**
* LogReader footer element.
*
* @property _elFt
* @type HTMLElement
* @private
*/
/**
* LogReader buttons container element.
*
* @property _elBtns
* @type HTMLElement
* @private
*/
/**
* Container element for LogReader category filter checkboxes.
*
* @property _elCategoryFilters
* @type HTMLElement
* @private
*/
/**
* Container element for LogReader source filter checkboxes.
*
* @property _elSourceFilters
* @type HTMLElement
* @private
*/
/**
* LogReader pause button element.
*
* @property _btnPause
* @type HTMLElement
* @private
*/
/**
* Clear button element.
*
* @property _btnClear
* @type HTMLElement
* @private
*/
/////////////////////////////////////////////////////////////////////////////
//
// Private methods
//
/////////////////////////////////////////////////////////////////////////////
/**
* Initializes the primary container element.
*
* @method _initContainerEl
* @param elContainer {HTMLElement} Container element by reference or string ID.
* @private
*/
// Validate container
// Attach to existing container...
this._elContainer = elContainer;
}
// ...or create container from scratch
else {
//this._elContainer.id = "yui-log" + this._sName;
//YAHOO.widget.LogReader._elDefaultContainer = this._elContainer;
// If implementer has provided container values, trust and set those
if(this.width) {
}
if(this.right) {
}
if(this.top) {
}
if(this.left) {
}
if(this.bottom) {
}
if(this.fontSize) {
}
// For Opera
}
}
};
/**
* Initializes the header element.
*
* @method _initHeaderEl
* @private
*/
var oSelf = this;
// Destroy header
if(this._elHd) {
// Unhook DOM events
// Remove DOM elements
}
// Create header
//this._btnCollapse.style.fontSize =
// YAHOO.util.Dom.getStyle(this._elContainer,"fontSize");
};
/**
* Initializes the console element.
*
* @method _initConsoleEl
* @private
*/
// Destroy console
if(this._elConsole) {
// Unhook DOM events
// Remove DOM elements
}
// Ceate console
// If implementer has provided console, trust and set those
if(this.height) {
}
};
/**
* Initializes the footer element.
*
* @method _initFooterEl
* @private
*/
var oSelf = this;
// Don't create footer elements if footer is disabled
if(this.footerEnabled) {
// Destroy console
if(this._elFt) {
// Unhook DOM events
// Remove DOM elements
}
//this._btnPause.style.fontSize =
// YAHOO.util.Dom.getStyle(this._elContainer,"fontSize");
//this._btnClear.style.fontSize =
// YAHOO.util.Dom.getStyle(this._elContainer,"fontSize");
}
};
/**
* Initializes Drag and Drop on the header element.
*
* @method _initDragDrop
* @private
*/
// If Drag and Drop utility is available...
// ...and draggable is true...
// ...then make the header draggable
//TODO: use class name
}
};
/**
* Initializes category filters.
*
* @method _initCategories
* @private
*/
// Initialize category filters
this._categoryFilters = [];
var sCategory = aInitialCategories[j];
// Add category to the internal array of filters
// Add checkbox element if UI is enabled
if(this._elCategoryFilters) {
this._createCategoryCheckbox(sCategory);
}
}
};
/**
* Initializes source filters.
*
* @method _initSources
* @private
*/
// Initialize source filters
this._sourceFilters = [];
var sSource = aInitialSources[j];
// Add source to the internal array of filters
// 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
*/
var oSelf = this;
if(this._elFt) {
var elParent = this._elCategoryFilters;
// Append el at the end so IE 5.5 can set "type" attribute
// and THEN set checked property
chkCategory.checked = true;
// Subscribe to the click event
// Create and class the text label
}
};
/**
* Creates a checkbox in the LogReader footer element to filter by source.
*
* @method _createSourceCheckbox
* @param sSource {String} Source name.
* @private
*/
var oSelf = this;
if(this._elFt) {
var elParent = this._elSourceFilters;
// Append el at the end so IE 5.5 can set "type" attribute
// and THEN set checked property
// Subscribe to the click event
// Create and class the text label
}
};
/**
* Reprints all log messages in the stack through filters.
*
* @method _filterLogs
* @private
*/
// Reprint stack with new filters
if (this._elConsole !== null) {
this.clearConsole();
}
};
/**
* Sends buffer of log messages to output and clears buffer.
*
* @method _printBuffer
* @private
*/
this._timeout = null;
if(this._elConsole !== null) {
var thresholdMax = this.thresholdMax;
if(this._consoleMsgCount < thresholdMax) {
var entries = [];
}
this._buffer = [];
this._printToConsole(entries);
}
else {
this._filterLogs();
}
if(!this.newestOnTop) {
}
}
};
/**
* 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
*/
// Manage the number of messages displayed in the console
var thresholdMin = this.thresholdMin;
thresholdMin = 0;
}
// Iterate through all log entries
for(var i=entriesStartIndex; i<entriesLen; i++) {
// Print only the ones that filter through
var okToPrint = false;
var okToFilterCats = false;
// Get log message details
for(var j=0; j<sourceFiltersLen; j++) {
if(source == this._sourceFilters[j]) {
okToFilterCats = true;
break;
}
}
if(okToFilterCats) {
for(var k=0; k<categoryFiltersLen; k++) {
if(category == this._categoryFilters[k]) {
okToPrint = true;
break;
}
}
}
if(okToPrint) {
if(this.newestOnTop) {
}
else {
}
this._consoleMsgCount++;
}
}
};
/////////////////////////////////////////////////////////////////////////////
//
// 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
*/
// Add category to the internal array of filters
}
};
/**
* 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
*/
// Add source to the internal array of filters
}
};
/**
* Handles check events on the category filter checkboxes.
*
* @method _onCheckCategory
* @param v {HTMLEvent} The click event.
* @param oSelf {Object} The LogReader instance.
* @private
*/
if(!this.checked) {
}
else {
}
};
/**
* Handles check events on the category filter checkboxes.
*
* @method _onCheckSource
* @param v {HTMLEvent} The click event.
* @param oSelf {Object} The LogReader instance.
* @private
*/
if(!this.checked) {
}
else {
}
};
/**
* Handles click events on the collapse button.
*
* @method _onClickCollapseBtn
* @param v {HTMLEvent} The click event.
* @param oSelf {Object} The LogReader instance
* @private
*/
if(!oSelf.isCollapsed) {
}
else {
}
};
/**
* Handles click events on the pause button.
*
* @method _onClickPauseBtn
* @param v {HTMLEvent} The click event.
* @param oSelf {Object} The LogReader instance.
* @private
*/
}
else {
}
};
/**
* Handles click events on the clear button.
*
* @method _onClickClearBtn
* @param v {HTMLEvent} The click event.
* @param oSelf {Object} The LogReader instance.
* @private
*/
};
/**
* 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
*/
}
};
/**
* 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
*/
oSelf._filterLogs();
};
/**
* 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.
* console.
*
* @module logger
* @requires yahoo, event, dom
* @optional dragdrop
* @namespace YAHOO.widget
* @title Logger Widget
*/
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
// Define once
/**
* 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
*/
// Initialize properties
loggerEnabled: true,
_browserConsoleEnabled: false,
sources: ["global"],
_stack: [], // holds all log msgs
maxStackEntries: 2500,
_lastTime: null // timestamp of last logged message
};
/////////////////////////////////////////////////////////////////////////////
//
// 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.
*/
if(this.loggerEnabled) {
if(!sCategory) {
}
else {
if(this._isNewCategory(sCategory)) {
this._createNewCategory(sCategory);
}
}
var sDetail = null;
if(sSource) {
if(spaceIndex > 0) {
// Substring until first space
// The rest of the source
}
else {
}
if(this._isNewSource(sClass)) {
this._createNewSource(sClass);
}
}
var timestamp = new Date();
});
var maxStackEntries = this.maxStackEntries;
}
if(this._browserConsoleEnabled) {
this._printToBrowserConsole(logEntry);
}
return true;
}
else {
return false;
}
};
/**
* Resets internal stack and startTime, enables Logger, and fires logResetEvent.
*
* @method reset
*/
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.
*/
return this._stack;
};
/**
* Public accessor to internal start time.
*
* @method getStartTime
* @return {Date} Internal date of when Logger singleton was initialized.
*/
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
*/
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
*/
this._browserConsoleEnabled = true;
};
/////////////////////////////////////////////////////////////////////////////
//
// Public events
//
/////////////////////////////////////////////////////////////////////////////
/**
* Fired when a new category has been created.
*
* @event categoryCreateEvent
* @param sCategory {String} Category name.
*/
/**
* Fired when a new source has been named.
*
* @event sourceCreateEvent
* @param sSource {String} Source name.
*/
/**
* Fired when a new log message has been created.
*
* @event newLogEvent
* @param sMsg {String} Log message.
*/
/**
* Fired when the Logger has been reset has been created.
*
* @event logResetEvent
*/
/////////////////////////////////////////////////////////////////////////////
//
// Private methods
//
/////////////////////////////////////////////////////////////////////////////
/**
* Creates a new category of log messages and fires categoryCreateEvent.
*
* @method _createNewCategory
* @param sCategory {String} Category name.
* @private
*/
};
/**
* 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
*/
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
*/
};
/**
* 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
*/
if(sSource) {
return false;
}
}
return true;
}
};
/**
* Outputs a log message to global console.log() function.
*
* @method _printToBrowserConsole
* @param oEntry {Object} Log entry object.
* @private
*/
if (time.toLocaleTimeString) {
}
else {
}
var output =
localTime + " (" +
elapsedTime + "ms): " +
}
};
/////////////////////////////////////////////////////////////////////////////
//
// 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
*/
// Logger is not in scope of this event handler
try {
}
}
catch(e) {
return false;
}
};
/////////////////////////////////////////////////////////////////////////////
//
// Enable handling of native JavaScript errors
// NB: Not all browsers support the window.onerror event
//
/////////////////////////////////////////////////////////////////////////////
// Save any previously defined handler to call
}
/////////////////////////////////////////////////////////////////////////////
//
// First log
//
/////////////////////////////////////////////////////////////////////////////
}