|
|
/*
|
|
|
Copyright (c) 2009, Yahoo! Inc. All rights reserved.
|
|
|
Code licensed under the BSD License:
|
|
|
http://developer.yahoo.net/yui/license.txt
|
|
|
version: 2.8.0r4
|
|
|
*/
|
|
|
(function() {
|
|
|
|
|
|
/**
|
|
|
* The ProfilerViewer module provides a graphical display for viewing
|
|
|
* the output of the YUI Profiler <http://developer.yahoo.com/yui/profiler>.
|
|
|
* @module profilerviewer
|
|
|
* @requires yahoo, dom, event, element, profiler, yuiloader
|
|
|
*/
|
|
|
|
|
|
/**
|
|
|
* A widget to view YUI Profiler output.
|
|
|
* @namespace YAHOO.widget
|
|
|
* @class ProfilerViewer
|
|
|
* @extends YAHOO.util.Element
|
|
|
* @constructor
|
|
|
* @param {HTMLElement | String | Object} el(optional) The html
|
|
|
* element into which the ProfileViewer should be rendered.
|
|
|
* An element will be created if none provided.
|
|
|
* @param {Object} attr (optional) A key map of the ProfilerViewer's
|
|
|
* initial attributes. Ignored if first arg is an attributes object.
|
|
|
*/
|
|
|
YAHOO.widget.ProfilerViewer = function(el, attr) {
|
|
|
attr = attr || {};
|
|
|
if (arguments.length == 1 && !YAHOO.lang.isString(el) && !el.nodeName) {
|
|
|
attr = el;
|
|
|
el = attr.element || null;
|
|
|
}
|
|
|
if (!el && !attr.element) {
|
|
|
el = this._createProfilerViewerElement();
|
|
|
}
|
|
|
|
|
|
YAHOO.widget.ProfilerViewer.superclass.constructor.call(this, el, attr);
|
|
|
|
|
|
this._init();
|
|
|
|
|
|
YAHOO.log("ProfilerViewer instantiated.", "info", "ProfilerViewer");
|
|
|
};
|
|
|
|
|
|
YAHOO.extend(YAHOO.widget.ProfilerViewer, YAHOO.util.Element);
|
|
|
|
|
|
// Static members of YAHOO.widget.ProfilerViewer:
|
|
|
YAHOO.lang.augmentObject(YAHOO.widget.ProfilerViewer, {
|
|
|
/**
|
|
|
* Classname for ProfilerViewer containing element.
|
|
|
* @static
|
|
|
* @property CLASS
|
|
|
* @type string
|
|
|
* @public
|
|
|
* @default "yui-pv"
|
|
|
*/
|
|
|
CLASS: 'yui-pv',
|
|
|
|
|
|
/**
|
|
|
* Classname for ProfilerViewer button dashboard.
|
|
|
* @static
|
|
|
* @property CLASS_DASHBOARD
|
|
|
* @type string
|
|
|
* @public
|
|
|
* @default "yui-pv-dashboard"
|
|
|
*/
|
|
|
CLASS_DASHBOARD: 'yui-pv-dashboard',
|
|
|
|
|
|
/**
|
|
|
* Classname for the "refresh data" button.
|
|
|
* @static
|
|
|
* @property CLASS_REFRESH
|
|
|
* @type string
|
|
|
* @public
|
|
|
* @default "yui-pv-refresh"
|
|
|
*/
|
|
|
CLASS_REFRESH: 'yui-pv-refresh',
|
|
|
|
|
|
/**
|
|
|
* Classname for busy indicator in the dashboard.
|
|
|
* @static
|
|
|
* @property CLASS_BUSY
|
|
|
* @type string
|
|
|
* @public
|
|
|
* @default "yui-pv-busy"
|
|
|
*/
|
|
|
CLASS_BUSY: 'yui-pv-busy',
|
|
|
|
|
|
/**
|
|
|
* Classname for element containing the chart and chart
|
|
|
* legend elements.
|
|
|
* @static
|
|
|
* @property CLASS_CHART_CONTAINER
|
|
|
* @type string
|
|
|
* @public
|
|
|
* @default "yui-pv-chartcontainer"
|
|
|
*/
|
|
|
CLASS_CHART_CONTAINER: 'yui-pv-chartcontainer',
|
|
|
|
|
|
/**
|
|
|
* Classname for element containing the chart.
|
|
|
* @static
|
|
|
* @property CLASS_CHART
|
|
|
* @type string
|
|
|
* @public
|
|
|
* @default "yui-pv-chart"
|
|
|
*/
|
|
|
CLASS_CHART: 'yui-pv-chart',
|
|
|
|
|
|
/**
|
|
|
* Classname for element containing the chart's legend.
|
|
|
* @static
|
|
|
* @property CLASS_CHART_LEGEND
|
|
|
* @type string
|
|
|
* @public
|
|
|
* @default "yui-pv-chartlegend"
|
|
|
*/
|
|
|
CLASS_CHART_LEGEND: 'yui-pv-chartlegend',
|
|
|
|
|
|
/**
|
|
|
* Classname for element containing the datatable.
|
|
|
* @static
|
|
|
* @property CLASS_TABLE
|
|
|
* @type string
|
|
|
* @public
|
|
|
* @default "yui-pv-table"
|
|
|
*/
|
|
|
CLASS_TABLE: 'yui-pv-table',
|
|
|
|
|
|
/**
|
|
|
* Strings used in the UI.
|
|
|
* @static
|
|
|
* @property STRINGS
|
|
|
* @object
|
|
|
* @public
|
|
|
* @default English language strings for UI.
|
|
|
*/
|
|
|
STRINGS: {
|
|
|
title: "YUI Profiler (beta)",
|
|
|
buttons: {
|
|
|
viewprofiler: "View Profiler Data",
|
|
|
hideprofiler: "Hide Profiler Report",
|
|
|
showchart: "Show Chart",
|
|
|
hidechart: "Hide Chart",
|
|
|
refreshdata: "Refresh Data"
|
|
|
},
|
|
|
colHeads: {
|
|
|
//key: [column head label, width in pixels]
|
|
|
fn: ["Function/Method", null], //must auto-size
|
|
|
calls: ["Calls", 40],
|
|
|
avg: ["Average", 80],
|
|
|
min: ["Shortest", 70],
|
|
|
max: ["Longest", 70],
|
|
|
total: ["Total Time", 70],
|
|
|
pct: ["Percent", 70]
|
|
|
},
|
|
|
millisecondsAbbrev: "ms",
|
|
|
initMessage: "initialiazing chart...",
|
|
|
installFlashMessage: "Unable to load Flash content. The YUI Charts Control requires Flash Player 9.0.45 or higher. You can download the latest version of Flash Player from the <a href='http://www.adobe.com/go/getflashplayer'>Adobe Flash Player Download Center</a>."
|
|
|
},
|
|
|
|
|
|
/**
|
|
|
* Function used to format numbers in milliseconds
|
|
|
* for chart; must be publicly accessible, per Charts spec.
|
|
|
* @static
|
|
|
* @property timeAxisLabelFunction
|
|
|
* @type function
|
|
|
* @private
|
|
|
*/
|
|
|
timeAxisLabelFunction: function(n) {
|
|
|
var a = (n === Math.floor(n)) ? n : (Math.round(n*1000))/1000;
|
|
|
return (a + " " + YAHOO.widget.ProfilerViewer.STRINGS.millisecondsAbbrev);
|
|
|
},
|
|
|
|
|
|
/**
|
|
|
* Function used to format percent numbers for chart; must
|
|
|
* be publicly accessible, per Charts spec.
|
|
|
* @static
|
|
|
* @property percentAxisLabelFunction
|
|
|
* @type function
|
|
|
* @private
|
|
|
*/
|
|
|
percentAxisLabelFunction: function(n) {
|
|
|
var a = (n === Math.floor(n)) ? n : (Math.round(n*100))/100;
|
|
|
return (a + "%");
|
|
|
}
|
|
|
|
|
|
|
|
|
},true);
|
|
|
|
|
|
|
|
|
//
|
|
|
// STANDARD SHORTCUTS
|
|
|
//
|
|
|
var Dom = YAHOO.util.Dom;
|
|
|
var Event = YAHOO.util.Event;
|
|
|
var Profiler = YAHOO.tool.Profiler;
|
|
|
var PV = YAHOO.widget.ProfilerViewer;
|
|
|
var proto = PV.prototype;
|
|
|
|
|
|
|
|
|
//
|
|
|
// PUBLIC METHODS
|
|
|
//
|
|
|
|
|
|
/**
|
|
|
* Refreshes the data displayed in the ProfilerViewer. When called,
|
|
|
* this will invoke a refresh of the DataTable and (if displayed)
|
|
|
* the Chart.
|
|
|
* @method refreshData
|
|
|
* @return void
|
|
|
* @public
|
|
|
*/
|
|
|
proto.refreshData = function() {
|
|
|
YAHOO.log("Data refresh requested via refreshData method.", "info", "ProfilerViewer");
|
|
|
this.fireEvent("dataRefreshEvent");
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Returns the element containing the console's header.
|
|
|
* @method getHeadEl
|
|
|
* @return HTMLElement
|
|
|
* @public
|
|
|
*/
|
|
|
proto.getHeadEl = function() {
|
|
|
YAHOO.log("Head element requested via getHeadEl.", "info", "ProfilerViewer");
|
|
|
return (this._headEl) ? Dom.get(this._headEl) : false;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Returns the element containing the console's body, including
|
|
|
* the chart and the datatable..
|
|
|
* @method getBodyEl
|
|
|
* @return HTMLElement
|
|
|
* @public
|
|
|
*/
|
|
|
proto.getBodyEl = function() {
|
|
|
YAHOO.log("Body element requested via getBodyEl.", "info", "ProfilerViewer");
|
|
|
return (this._bodyEl) ? Dom.get(this._bodyEl) : false;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Returns the element containing the console's chart.
|
|
|
* @method getChartEl
|
|
|
* @return HTMLElement
|
|
|
* @public
|
|
|
*/
|
|
|
proto.getChartEl = function() {
|
|
|
YAHOO.log("Chart element requested via getChartEl.", "info", "ProfilerViewer");
|
|
|
return (this._chartEl) ? Dom.get(this._chartEl) : false;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Returns the element containing the console's dataTable.
|
|
|
* @method getTableEl
|
|
|
* @return HTMLElement
|
|
|
* @public
|
|
|
*/
|
|
|
proto.getTableEl = function() {
|
|
|
YAHOO.log("DataTable element requested via getTableEl.", "info", "ProfilerViewer");
|
|
|
return (this._tableEl) ? Dom.get(this._tableEl) : false;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Returns the element containing the console's DataTable
|
|
|
* instance.
|
|
|
* @method getDataTable
|
|
|
* @return YAHOO.widget.DataTable
|
|
|
* @public
|
|
|
*/
|
|
|
proto.getDataTable = function() {
|
|
|
YAHOO.log("DataTable instance requested via getDataTable.", "info", "ProfilerViewer");
|
|
|
return this._dataTable;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Returns the element containing the console's Chart instance.
|
|
|
* @method getChart
|
|
|
* @return YAHOO.widget.BarChart
|
|
|
* @public
|
|
|
*/
|
|
|
proto.getChart = function() {
|
|
|
YAHOO.log("Chart instance requested via getChart.", "info", "ProfilerViewer");
|
|
|
return this._chart;
|
|
|
};
|
|
|
|
|
|
|
|
|
//
|
|
|
// PRIVATE PROPERTIES
|
|
|
//
|
|
|
proto._rendered = false;
|
|
|
proto._headEl = null;
|
|
|
proto._bodyEl = null;
|
|
|
proto._toggleVisibleEl = null;
|
|
|
proto._busyEl = null;
|
|
|
proto._busy = false;
|
|
|
|
|
|
proto._tableEl = null;
|
|
|
proto._dataTable = null;
|
|
|
|
|
|
proto._chartEl = null;
|
|
|
proto._chartLegendEl = null;
|
|
|
proto._chartElHeight = 250;
|
|
|
proto._chart = null;
|
|
|
proto._chartInitialized = false;
|
|
|
|
|
|
//
|
|
|
// PRIVATE METHODS
|
|
|
//
|
|
|
|
|
|
proto._init = function() {
|
|
|
/**
|
|
|
* CUSTOM EVENTS
|
|
|
**/
|
|
|
|
|
|
/**
|
|
|
* Fired when a data refresh is requested. No arguments are passed
|
|
|
* with this event.
|
|
|
*
|
|
|
* @event refreshDataEvent
|
|
|
*/
|
|
|
this.createEvent("dataRefreshEvent");
|
|
|
|
|
|
/**
|
|
|
* Fired when the viewer canvas first renders. No arguments are passed
|
|
|
* with this event.
|
|
|
*
|
|
|
* @event renderEvent
|
|
|
*/
|
|
|
this.createEvent("renderEvent");
|
|
|
|
|
|
this.on("dataRefreshEvent", this._refreshDataTable, this, true);
|
|
|
|
|
|
this._initLauncherDOM();
|
|
|
|
|
|
if(this.get("showChart")) {
|
|
|
this.on("sortedByChange", this._refreshChart);
|
|
|
}
|
|
|
|
|
|
YAHOO.log("ProfilerViewer instance initialization complete.", "info", "ProfilerViewer");
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* If no element is passed in, create it as the first element
|
|
|
* in the document.
|
|
|
* @method _createProfilerViewerElement
|
|
|
* @return HTMLElement
|
|
|
* @private
|
|
|
*/
|
|
|
proto._createProfilerViewerElement = function() {
|
|
|
YAHOO.log("Creating root element...", "info", "ProfilerViewer");
|
|
|
|
|
|
var el = document.createElement("div");
|
|
|
document.body.insertBefore(el, document.body.firstChild);
|
|
|
Dom.addClass(el, this.SKIN_CLASS);
|
|
|
Dom.addClass(el, PV.CLASS);
|
|
|
YAHOO.log(el);
|
|
|
return el;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Provides a readable name for the ProfilerViewer instance.
|
|
|
* @method toString
|
|
|
* @return String
|
|
|
* @private
|
|
|
*/
|
|
|
proto.toString = function() {
|
|
|
return "ProfilerViewer " + (this.get('id') || this.get('tagName'));
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Toggles visibility of the viewer canvas.
|
|
|
* @method _toggleVisible
|
|
|
* @return void
|
|
|
* @private
|
|
|
*/
|
|
|
proto._toggleVisible = function() {
|
|
|
YAHOO.log("Toggling visibility to " + !this.get("visible") + ".", "info", "ProfilerViewer");
|
|
|
|
|
|
var newVis = (this.get("visible")) ? false : true;
|
|
|
this.set("visible", newVis);
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Shows the viewer canvas.
|
|
|
* @method show
|
|
|
* @return void
|
|
|
* @private
|
|
|
*/
|
|
|
proto._show = function() {
|
|
|
if(!this._busy) {
|
|
|
this._setBusyState(true);
|
|
|
if(!this._rendered) {
|
|
|
var loader = new YAHOO.util.YUILoader();
|
|
|
if (this.get("base")) {
|
|
|
loader.base = this.get("base");
|
|
|
}
|
|
|
|
|
|
var modules = ["datatable"];
|
|
|
if(this.get("showChart")) {
|
|
|
modules.push("charts");
|
|
|
}
|
|
|
|
|
|
loader.insert({ require: modules,
|
|
|
onSuccess: function() {
|
|
|
this._render();
|
|
|
},
|
|
|
scope: this});
|
|
|
} else {
|
|
|
var el = this.get("element");
|
|
|
Dom.removeClass(el, "yui-pv-minimized");
|
|
|
this._toggleVisibleEl.innerHTML = PV.STRINGS.buttons.hideprofiler;
|
|
|
|
|
|
//The Flash Charts component can't be set to display:none,
|
|
|
//and even after positioning it offscreen the screen
|
|
|
//may fail to repaint in some browsers. Adding an empty
|
|
|
//style rule to the console body can help force a repaint:
|
|
|
Dom.addClass(el, "yui-pv-null");
|
|
|
Dom.removeClass(el, "yui-pv-null");
|
|
|
|
|
|
//Always refresh data when changing to visible:
|
|
|
this.refreshData();
|
|
|
}
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Hides the viewer canvas.
|
|
|
* @method hide
|
|
|
* @return void
|
|
|
* @private
|
|
|
*/
|
|
|
proto._hide = function() {
|
|
|
this._toggleVisibleEl.innerHTML = PV.STRINGS.buttons.viewprofiler;
|
|
|
Dom.addClass(this.get("element"), "yui-pv-minimized");
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Render the viewer canvas
|
|
|
* @method _render
|
|
|
* @return void
|
|
|
* @private
|
|
|
*/
|
|
|
proto._render = function() {
|
|
|
YAHOO.log("Beginning to render ProfilerViewer canvas...", "info", "ProfilerViewer");
|
|
|
|
|
|
Dom.removeClass(this.get("element"), "yui-pv-minimized");
|
|
|
|
|
|
this._initViewerDOM();
|
|
|
this._initDataTable();
|
|
|
if(this.get("showChart")) {
|
|
|
this._initChartDOM();
|
|
|
this._initChart();
|
|
|
}
|
|
|
this._rendered = true;
|
|
|
this._toggleVisibleEl.innerHTML = PV.STRINGS.buttons.hideprofiler;
|
|
|
|
|
|
this.fireEvent("renderEvent");
|
|
|
|
|
|
YAHOO.log("ProfilerViewer rendering complete...", "info", "ProfilerViewer");
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Set up the DOM structure for the ProfilerViewer launcher.
|
|
|
* @method _initLauncherDOM
|
|
|
* @private
|
|
|
*/
|
|
|
proto._initLauncherDOM = function() {
|
|
|
YAHOO.log("Creating the launcher...", "info", "ProfilerViewer");
|
|
|
|
|
|
var el = this.get("element");
|
|
|
Dom.addClass(el, PV.CLASS);
|
|
|
Dom.addClass(el, "yui-pv-minimized");
|
|
|
|
|
|
this._headEl = document.createElement("div");
|
|
|
Dom.addClass(this._headEl, "hd");
|
|
|
|
|
|
var s = PV.STRINGS.buttons;
|
|
|
var b = (this.get("visible")) ? s.hideprofiler : s.viewprofiler;
|
|
|
|
|
|
this._toggleVisibleEl = this._createButton(b, this._headEl);
|
|
|
|
|
|
this._refreshEl = this._createButton(s.refreshdata, this._headEl);
|
|
|
Dom.addClass(this._refreshEl, PV.CLASS_REFRESH);
|
|
|
|
|
|
this._busyEl = document.createElement("span");
|
|
|
this._headEl.appendChild(this._busyEl);
|
|
|
|
|
|
var title = document.createElement("h4");
|
|
|
title.innerHTML = PV.STRINGS.title;
|
|
|
this._headEl.appendChild(title);
|
|
|
|
|
|
el.appendChild(this._headEl);
|
|
|
|
|
|
Event.on(this._toggleVisibleEl, "click", this._toggleVisible, this, true);
|
|
|
Event.on(this._refreshEl, "click", function() {
|
|
|
if(!this._busy) {
|
|
|
this._setBusyState(true);
|
|
|
this.fireEvent("dataRefreshEvent");
|
|
|
}
|
|
|
}, this, true);
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Set up the DOM structure for the ProfilerViewer canvas,
|
|
|
* including the holder for the DataTable.
|
|
|
* @method _initViewerDOM
|
|
|
* @private
|
|
|
*/
|
|
|
proto._initViewerDOM = function() {
|
|
|
YAHOO.log("Creating DOM structure for viewer...", "info", "ProfilerViewer");
|
|
|
|
|
|
var el = this.get("element");
|
|
|
this._bodyEl = document.createElement("div");
|
|
|
Dom.addClass(this._bodyEl, "bd");
|
|
|
this._tableEl = document.createElement("div");
|
|
|
Dom.addClass(this._tableEl, PV.CLASS_TABLE);
|
|
|
this._bodyEl.appendChild(this._tableEl);
|
|
|
el.appendChild(this._bodyEl);
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Set up the DOM structure for the ProfilerViewer canvas.
|
|
|
* @method _initChartDOM
|
|
|
* @private
|
|
|
*/
|
|
|
proto._initChartDOM = function() {
|
|
|
YAHOO.log("Adding DOM structure for chart...", "info", "ProfilerViewer");
|
|
|
|
|
|
this._chartContainer = document.createElement("div");
|
|
|
Dom.addClass(this._chartContainer, PV.CLASS_CHART_CONTAINER);
|
|
|
|
|
|
var chl = document.createElement("div");
|
|
|
Dom.addClass(chl, PV.CLASS_CHART_LEGEND);
|
|
|
|
|
|
var chw = document.createElement("div");
|
|
|
|
|
|
this._chartLegendEl = document.createElement("dl");
|
|
|
this._chartLegendEl.innerHTML = "<dd>" + PV.STRINGS.initMessage + "</dd>";
|
|
|
|
|
|
this._chartEl = document.createElement("div");
|
|
|
Dom.addClass(this._chartEl, PV.CLASS_CHART);
|
|
|
|
|
|
var msg = document.createElement("p");
|
|
|
msg.innerHTML = PV.STRINGS.installFlashMessage;
|
|
|
this._chartEl.appendChild(msg);
|
|
|
|
|
|
this._chartContainer.appendChild(chl);
|
|
|
chl.appendChild(chw);
|
|
|
chw.appendChild(this._chartLegendEl);
|
|
|
this._chartContainer.appendChild(this._chartEl);
|
|
|
this._bodyEl.insertBefore(this._chartContainer,this._tableEl);
|
|
|
};
|
|
|
|
|
|
|
|
|
/**
|
|
|
* Create anchor elements for use as buttons. Args: label
|
|
|
* is text to appear on the face of the button, parentEl
|
|
|
* is the el to which the anchor will be attached, position
|
|
|
* is true for inserting as the first node and false for
|
|
|
* inserting as the last node of the parentEl.
|
|
|
* @method _createButton
|
|
|
* @private
|
|
|
*/
|
|
|
proto._createButton = function(label, parentEl, position) {
|
|
|
var b = document.createElement("a");
|
|
|
b.innerHTML = b.title = label;
|
|
|
if(parentEl) {
|
|
|
if(!position) {
|
|
|
parentEl.appendChild(b);
|
|
|
} else {
|
|
|
parentEl.insertBefore(b, parentEl.firstChild);
|
|
|
}
|
|
|
}
|
|
|
return b;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Set's console busy state.
|
|
|
* @method _setBusyState
|
|
|
* @private
|
|
|
**/
|
|
|
proto._setBusyState = function(b) {
|
|
|
if(b) {
|
|
|
Dom.addClass(this._busyEl, PV.CLASS_BUSY);
|
|
|
this._busy = true;
|
|
|
} else {
|
|
|
Dom.removeClass(this._busyEl, PV.CLASS_BUSY);
|
|
|
this._busy = false;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Generages a sorting function based on current sortedBy
|
|
|
* values.
|
|
|
* @method _createProfilerViewerElement
|
|
|
* @private
|
|
|
**/
|
|
|
proto._genSortFunction = function(key, dir) {
|
|
|
var by = key;
|
|
|
var direction = dir;
|
|
|
return function(a, b) {
|
|
|
if (direction == YAHOO.widget.DataTable.CLASS_ASC) {
|
|
|
return a[by] - b[by];
|
|
|
} else {
|
|
|
return ((a[by] - b[by]) * -1);
|
|
|
}
|
|
|
};
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Utility function for array sums.
|
|
|
* @method _arraySum
|
|
|
* @private
|
|
|
**/
|
|
|
var _arraySum = function(arr){
|
|
|
var ct = 0;
|
|
|
for(var i = 0; i < arr.length; ct+=arr[i++]){}
|
|
|
return ct;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Retrieves data from Profiler, filtering and sorting as needed
|
|
|
* based on current widget state. Adds calculated percentage
|
|
|
* column and function name to data returned by Profiler.
|
|
|
* @method _getProfilerData
|
|
|
* @private
|
|
|
**/
|
|
|
proto._getProfilerData = function() {
|
|
|
YAHOO.log("Profiler data requested from function DataSource.", "info", "ProfilerViewer");
|
|
|
|
|
|
var obj = Profiler.getFullReport();
|
|
|
var arr = [];
|
|
|
var totalTime = 0;
|
|
|
for (name in obj) {
|
|
|
if (YAHOO.lang.hasOwnProperty(obj, name)) {
|
|
|
var r = obj[name];
|
|
|
var o = {};
|
|
|
o.fn = name; //add function name to record
|
|
|
o.points = r.points.slice(); //copy live array
|
|
|
o.calls = r.calls;
|
|
|
o.min = r.min;
|
|
|
o.max = r.max;
|
|
|
o.avg = r.avg;
|
|
|
o.total = _arraySum(o.points);
|
|
|
o.points = r.points;
|
|
|
var f = this.get("filter");
|
|
|
if((!f) || (f(o))) {
|
|
|
arr.push(o);
|
|
|
totalTime += o.total;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
//add calculated percentage column
|
|
|
for (var i = 0, j = arr.length; i < j; i++) {
|
|
|
arr[i].pct = (totalTime) ? (arr[i].total * 100) / totalTime : 0;
|
|
|
}
|
|
|
|
|
|
var sortedBy = this.get("sortedBy");
|
|
|
var key = sortedBy.key;
|
|
|
var dir = sortedBy.dir;
|
|
|
|
|
|
arr.sort(this._genSortFunction(key, dir));
|
|
|
|
|
|
YAHOO.log("Returning data from DataSource: " + YAHOO.lang.dump(arr), "info", "ProfilerViewer");
|
|
|
|
|
|
return arr;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Set up the DataTable.
|
|
|
* @method _initDataTable
|
|
|
* @private
|
|
|
*/
|
|
|
proto._initDataTable = function() {
|
|
|
YAHOO.log("Creating DataTable instance...", "info", "ProfilerViewer");
|
|
|
|
|
|
var self = this;
|
|
|
|
|
|
//Set up the JS Function DataSource, pulling data from
|
|
|
//the Profiler.
|
|
|
this._dataSource = new YAHOO.util.DataSource(
|
|
|
function() {
|
|
|
return self._getProfilerData.call(self);
|
|
|
},
|
|
|
{
|
|
|
responseType: YAHOO.util.DataSource.TYPE_JSARRAY,
|
|
|
maxCacheEntries: 0
|
|
|
}
|
|
|
);
|
|
|
var ds = this._dataSource;
|
|
|
|
|
|
ds.responseSchema =
|
|
|
{
|
|
|
fields: [ "fn", "avg", "calls", "max", "min", "total", "pct", "points"]
|
|
|
};
|
|
|
|
|
|
//Set up the DataTable.
|
|
|
var formatTimeValue = function(elCell, oRecord, oColumn, oData) {
|
|
|
var a = (oData === Math.floor(oData)) ? oData : (Math.round(oData*1000))/1000;
|
|
|
elCell.innerHTML = a + " " + PV.STRINGS.millisecondsAbbrev;
|
|
|
};
|
|
|
|
|
|
var formatPercent = function(elCell, oRecord, oColumn, oData) {
|
|
|
var a = (oData === Math.floor(oData)) ? oData : (Math.round(oData*100))/100;
|
|
|
elCell.innerHTML = a + "%";
|
|
|
};
|
|
|
|
|
|
var a = YAHOO.widget.DataTable.CLASS_ASC;
|
|
|
var d = YAHOO.widget.DataTable.CLASS_DESC;
|
|
|
var c = PV.STRINGS.colHeads;
|
|
|
var f = formatTimeValue;
|
|
|
|
|
|
var cols = [
|
|
|
{key:"fn", sortable:true, label: c.fn[0],
|
|
|
sortOptions: {defaultDir:a},
|
|
|
resizeable: (YAHOO.util.DragDrop) ? true : false,
|
|
|
minWidth:c.fn[1]},
|
|
|
{key:"calls", sortable:true, label: c.calls[0],
|
|
|
sortOptions: {defaultDir:d},
|
|
|
width:c.calls[1]},
|
|
|
{key:"avg", sortable:true, label: c.avg[0],
|
|
|
sortOptions: {defaultDir:d},
|
|
|
formatter:f,
|
|
|
width:c.avg[1]},
|
|
|
{key:"min", sortable:true, label: c.min[0],
|
|
|
sortOptions: {defaultDir:a},
|
|
|
formatter:f,
|
|
|
width:c.min[1]},
|
|
|
{key:"max", sortable:true, label: c.max[0],
|
|
|
sortOptions: {defaultDir:d},
|
|
|
formatter:f,
|
|
|
width:c.max[1]},
|
|
|
{key:"total", sortable:true, label: c.total[0],
|
|
|
sortOptions: {defaultDir:d},
|
|
|
formatter:f,
|
|
|
width:c.total[1]},
|
|
|
{key:"pct", sortable:true, label: c.pct[0],
|
|
|
sortOptions: {defaultDir:d},
|
|
|
formatter:formatPercent,
|
|
|
width:c.pct[1]}
|
|
|
];
|
|
|
|
|
|
this._dataTable = new YAHOO.widget.DataTable(this._tableEl, cols, ds, {
|
|
|
scrollable:true,
|
|
|
height:this.get("tableHeight"),
|
|
|
initialRequest:null,
|
|
|
sortedBy: {
|
|
|
key: "total",
|
|
|
dir: YAHOO.widget.DataTable.CLASS_DESC
|
|
|
}
|
|
|
});
|
|
|
var dt = this._dataTable;
|
|
|
|
|
|
//Wire up DataTable events to drive the rest of the UI.
|
|
|
dt.subscribe("sortedByChange", this._sortedByChange, this, true);
|
|
|
dt.subscribe("renderEvent", this._dataTableRenderHandler, this, true);
|
|
|
dt.subscribe("initEvent", this._dataTableRenderHandler, this, true);
|
|
|
Event.on(this._tableEl.getElementsByTagName("th"), "click", this._thClickHandler, this, true);
|
|
|
YAHOO.log("DataTable initialized.", "info", "ProfilerViewer");
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Proxy the sort event in DataTable into the ProfilerViewer
|
|
|
* attribute.
|
|
|
* @method _sortedByChange
|
|
|
* @private
|
|
|
**/
|
|
|
proto._sortedByChange = function(o) {
|
|
|
if(o.newValue && o.newValue.key) {
|
|
|
YAHOO.log("Relaying DataTable sortedBy value change; new key: " + o.newValue.key + "; new direction: " + o.newValue.dir + ".", "info", "ProfilerViewer");
|
|
|
this.set("sortedBy", {key: o.newValue.key, dir:o.newValue.dir});
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Proxy the render event in DataTable into the ProfilerViewer
|
|
|
* attribute.
|
|
|
* @method _dataTableRenderHandler
|
|
|
* @private
|
|
|
**/
|
|
|
proto._dataTableRenderHandler = function(o) {
|
|
|
YAHOO.log("DataTable's render event has fired.", "info", "ProfilerViewer");
|
|
|
this._setBusyState(false);
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Event handler for clicks on the DataTable's sortable column
|
|
|
* heads.
|
|
|
* @method _thClickHandler
|
|
|
* @private
|
|
|
**/
|
|
|
proto._thClickHandler = function(o) {
|
|
|
YAHOO.log("DataTable's header row was clicked for sorting.", "info", "ProfilerViewer");
|
|
|
this._setBusyState(true);
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Refresh DataTable, getting new data from Profiler.
|
|
|
* @method _refreshDataTable
|
|
|
* @private
|
|
|
**/
|
|
|
proto._refreshDataTable = function(args) {
|
|
|
YAHOO.log("Beginning to refresh DataTable contents...", "info", "ProfilerViewer");
|
|
|
var dt = this._dataTable;
|
|
|
dt.getDataSource().sendRequest("", dt.onDataReturnInitializeTable, dt);
|
|
|
YAHOO.log("DataTable refresh complete.", "info", "ProfilerViewer");
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Refresh chart, getting new data from table.
|
|
|
* @method _refreshChart
|
|
|
* @private
|
|
|
**/
|
|
|
proto._refreshChart = function() {
|
|
|
YAHOO.log("Beginning to refresh Chart contents...", "info", "ProfilerViewer");
|
|
|
|
|
|
switch (this.get("sortedBy").key) {
|
|
|
case "fn":
|
|
|
/*Keep the same data on the chart, but force update to
|
|
|
reflect new sort order on function/method name: */
|
|
|
this._chart.set("dataSource", this._chart.get("dataSource"));
|
|
|
/*no further action necessary; chart redraws*/
|
|
|
return;
|
|
|
case "calls":
|
|
|
/*Null out the xAxis formatting before redrawing chart.*/
|
|
|
this._chart.set("xAxis", this._chartAxisDefinitionPlain);
|
|
|
break;
|
|
|
case "pct":
|
|
|
this._chart.set("xAxis", this._chartAxisDefinitionPercent);
|
|
|
break;
|
|
|
default:
|
|
|
/*Set the default xAxis; redraw legend; set the new series definition.*/
|
|
|
this._chart.set("xAxis", this._chartAxisDefinitionTime);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
this._drawChartLegend();
|
|
|
this._chart.set("series", this._getSeriesDef(this.get("sortedBy").key));
|
|
|
|
|
|
YAHOO.log("Chart refresh complete.", "info", "ProfilerViewer");
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Get data for the Chart from DataTable recordset
|
|
|
* @method _getChartData
|
|
|
* @private
|
|
|
*/
|
|
|
proto._getChartData = function() {
|
|
|
YAHOO.log("Getting data for chart from function DataSource.", "info", "ProfilerViewer");
|
|
|
//var records = this._getProfilerData();
|
|
|
var records = this._dataTable.getRecordSet().getRecords(0, this.get("maxChartFunctions"));
|
|
|
var arr = [];
|
|
|
for (var i = 0, j = records.length; i<j; i++) {
|
|
|
arr.push(records[i].getData());
|
|
|
}
|
|
|
YAHOO.log("Returning data to Chart: " + YAHOO.lang.dump(arr), "info", "ProfilerViewer");
|
|
|
return arr;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Build series definition based on current configuration attributes.
|
|
|
* @method _getSeriesDef
|
|
|
* @private
|
|
|
*/
|
|
|
proto._getSeriesDef = function(field) {
|
|
|
var sd = this.get("chartSeriesDefinitions")[field];
|
|
|
var arr = [];
|
|
|
for(var i = 0, j = sd.group.length; i<j; i++) {
|
|
|
var c = this.get("chartSeriesDefinitions")[sd.group[i]];
|
|
|
arr.push(
|
|
|
{displayName:c.displayName,
|
|
|
xField:c.xField,
|
|
|
style: {color:c.style.color, size:c.style.size}
|
|
|
}
|
|
|
);
|
|
|
}
|
|
|
|
|
|
YAHOO.log("Returning new series definition to chart: " + YAHOO.lang.dump(arr), "info", "ProfilerViewer");
|
|
|
return arr;
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Set up the Chart.
|
|
|
* @method _initChart
|
|
|
* @private
|
|
|
*/
|
|
|
proto._initChart = function() {
|
|
|
YAHOO.log("Initializing chart...", "info", "ProfilerViewer");
|
|
|
|
|
|
this._sizeChartCanvas();
|
|
|
|
|
|
YAHOO.widget.Chart.SWFURL = this.get("swfUrl");
|
|
|
|
|
|
var self = this;
|
|
|
|
|
|
//Create DataSource based on records currently displayed
|
|
|
//at the top of the sort list in the DataTable.
|
|
|
var ds = new YAHOO.util.DataSource(
|
|
|
//force the jsfunction DataSource to run in the scope of
|
|
|
//the ProfilerViewer, not in the YAHOO.util.DataSource scope:
|
|
|
function() {
|
|
|
return self._getChartData.call(self);
|
|
|
},
|
|
|
{
|
|
|
responseType: YAHOO.util.DataSource.TYPE_JSARRAY,
|
|
|
maxCacheEntries: 0
|
|
|
}
|
|
|
);
|
|
|
|
|
|
ds.responseSchema =
|
|
|
{
|
|
|
fields: [ "fn", "avg", "calls", "max", "min", "total", "pct" ]
|
|
|
};
|
|
|
|
|
|
ds.subscribe('responseEvent', this._sizeChartCanvas, this, true);
|
|
|
|
|
|
//Set up the chart itself.
|
|
|
this._chartAxisDefinitionTime = new YAHOO.widget.NumericAxis();
|
|
|
this._chartAxisDefinitionTime.labelFunction = "YAHOO.widget.ProfilerViewer.timeAxisLabelFunction";
|
|
|
|
|
|
this._chartAxisDefinitionPercent = new YAHOO.widget.NumericAxis();
|
|
|
this._chartAxisDefinitionPercent.labelFunction = "YAHOO.widget.ProfilerViewer.percentAxisLabelFunction";
|
|
|
|
|
|
this._chartAxisDefinitionPlain = new YAHOO.widget.NumericAxis();
|
|
|
|
|
|
this._chart = new YAHOO.widget.BarChart( this._chartEl, ds,
|
|
|
{
|
|
|
yField: "fn",
|
|
|
series: this._getSeriesDef(this.get("sortedBy").key),
|
|
|
style: this.get("chartStyle"),
|
|
|
xAxis: this._chartAxisDefinitionTime
|
|
|
} );
|
|
|
|
|
|
this._drawChartLegend();
|
|
|
this._chartInitialized = true;
|
|
|
this._dataTable.unsubscribe("initEvent", this._initChart, this);
|
|
|
this._dataTable.subscribe("initEvent", this._refreshChart, this, true);
|
|
|
|
|
|
YAHOO.log("Chart initialization complete.", "info", "ProfilerViewer");
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Set up the Chart's legend
|
|
|
* @method _drawChartLegend
|
|
|
* @private
|
|
|
**/
|
|
|
proto._drawChartLegend = function() {
|
|
|
YAHOO.log("Drawing chart legend...", "info", "ProfilerViewer");
|
|
|
var seriesDefs = this.get("chartSeriesDefinitions");
|
|
|
var currentDef = seriesDefs[this.get("sortedBy").key];
|
|
|
var l = this._chartLegendEl;
|
|
|
l.innerHTML = "";
|
|
|
for(var i = 0, j = currentDef.group.length; i<j; i++) {
|
|
|
var c = seriesDefs[currentDef.group[i]];
|
|
|
var dt = document.createElement("dt");
|
|
|
Dom.setStyle(dt, "backgroundColor", "#" + c.style.color);
|
|
|
var dd = document.createElement("dd");
|
|
|
dd.innerHTML = c.displayName;
|
|
|
l.appendChild(dt);
|
|
|
l.appendChild(dd);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* Resize the chart's canvas if based on number of records
|
|
|
* returned from the chart's datasource.
|
|
|
* @method _sizeChartCanvas
|
|
|
* @private
|
|
|
**/
|
|
|
proto._sizeChartCanvas = function(o) {
|
|
|
YAHOO.log("Resizing chart canvas...", "info", "ProfilerViewer");
|
|
|
var bars = (o) ? o.response.length : this.get("maxChartFunctions");
|
|
|
var s = (bars * 36) + 34;
|
|
|
if (s != parseInt(this._chartElHeight, 10)) {
|
|
|
this._chartElHeight = s;
|
|
|
Dom.setStyle(this._chartEl, "height", s + "px");
|
|
|
}
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* setAttributeConfigs TabView specific properties.
|
|
|
* @method initAttributes
|
|
|
* @param {Object} attr Hash of initial attributes
|
|
|
* @method initAttributes
|
|
|
* @private
|
|
|
*/
|
|
|
proto.initAttributes = function(attr) {
|
|
|
YAHOO.log("Initializing attributes...", "info", "ProfilerViewer");
|
|
|
YAHOO.widget.ProfilerViewer.superclass.initAttributes.call(this, attr);
|
|
|
/**
|
|
|
* The YUI Loader base path from which to pull YUI files needed
|
|
|
* in the rendering of the ProfilerViewer canvas. Passed directly
|
|
|
* to YUI Loader. Leave blank to draw files from
|
|
|
* yui.yahooapis.com.
|
|
|
* @attribute base
|
|
|
* @type string
|
|
|
* @default ""
|
|
|
*/
|
|
|
this.setAttributeConfig('base', {
|
|
|
value: attr.base
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* The height of the DataTable. The table will scroll
|
|
|
* vertically if the content overflows the specified
|
|
|
* height.
|
|
|
* @attribute tableHeight
|
|
|
* @type string
|
|
|
* @default "15em"
|
|
|
*/
|
|
|
this.setAttributeConfig('tableHeight', {
|
|
|
value: attr.tableHeight || "15em",
|
|
|
method: function(s) {
|
|
|
if(this._dataTable) {
|
|
|
this._dataTable.set("height", s);
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* The default column key to sort by. Valid keys are: fn, calls,
|
|
|
* avg, min, max, total. Valid dir values are:
|
|
|
* YAHOO.widget.DataTable.CLASS_ASC and
|
|
|
* YAHOO.widget.DataTable.CLASS_DESC (or their
|
|
|
* string equivalents).
|
|
|
* @attribute sortedBy
|
|
|
* @type string
|
|
|
* @default {key:"total", dir:"yui-dt-desc"}
|
|
|
*/
|
|
|
this.setAttributeConfig('sortedBy', {
|
|
|
value: attr.sortedBy || {key:"total", dir:"yui-dt-desc"}
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* A filter function to use in selecting functions that will
|
|
|
* appear in the ProfilerViewer report. The function is passed
|
|
|
* a function report object and should return a boolean indicating
|
|
|
* whether that function should be included in the ProfilerViewer
|
|
|
* display. The argument is structured as follows:
|
|
|
*
|
|
|
* {
|
|
|
* fn: <str function name>,
|
|
|
* calls : <n number of calls>,
|
|
|
* avg : <n average call duration>,
|
|
|
* max: <n duration of longest call>,
|
|
|
* min: <n duration of shortest call>,
|
|
|
* total: <n total time of all calls>
|
|
|
* points : <array time in ms of each call>
|
|
|
* }
|
|
|
*
|
|
|
* For example, you would use the follwing filter function to
|
|
|
* return only functions that have been called at least once:
|
|
|
*
|
|
|
* function(o) {
|
|
|
* return (o.calls > 0);
|
|
|
* }
|
|
|
*
|
|
|
* @attribute filter
|
|
|
* @type function
|
|
|
* @default null
|
|
|
*/
|
|
|
this.setAttributeConfig('filter', {
|
|
|
value: attr.filter || null,
|
|
|
validator: YAHOO.lang.isFunction
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* The path to the YUI Charts swf file; must be a full URI
|
|
|
* or a path relative to the page being profiled. Changes at runtime
|
|
|
* not supported; pass this value in at instantiation.
|
|
|
* @attribute swfUrl
|
|
|
* @type string
|
|
|
* @default "http://yui.yahooapis.com/2.5.0/build/charts/assets/charts.swf"
|
|
|
*/
|
|
|
this.setAttributeConfig('swfUrl', {
|
|
|
value: attr.swfUrl || "http://yui.yahooapis.com/2.5.0/build/charts/assets/charts.swf"
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* The maximum number of functions to profile in the chart. The
|
|
|
* greater the number of functions, the greater the height of the
|
|
|
* chart canvas.
|
|
|
* height.
|
|
|
* @attribute maxChartFunctions
|
|
|
* @type int
|
|
|
* @default 6
|
|
|
*/
|
|
|
this.setAttributeConfig('maxChartFunctions', {
|
|
|
value: attr.maxChartFunctions || 6,
|
|
|
method: function(s) {
|
|
|
if(this._rendered) {
|
|
|
this._sizeChartCanvas();
|
|
|
}
|
|
|
},
|
|
|
validator: YAHOO.lang.isNumber
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* The style object that defines the chart's visual presentation.
|
|
|
* Conforms to the style attribute passed to the Charts Control
|
|
|
* constructor. See Charts Control User's Guide for more information
|
|
|
* on how to format this object.
|
|
|
* @attribute chartStyle
|
|
|
* @type obj
|
|
|
* @default See JS source for default definitions.
|
|
|
*/
|
|
|
this.setAttributeConfig('chartStyle', {
|
|
|
value: attr.chartStyle || {
|
|
|
font:
|
|
|
{
|
|
|
name: "Arial",
|
|
|
color: 0xeeee5c,
|
|
|
size: 12
|
|
|
},
|
|
|
background:
|
|
|
{
|
|
|
color: "6e6e63"
|
|
|
}
|
|
|
},
|
|
|
method: function() {
|
|
|
if(this._rendered && this.get("showChart")) {
|
|
|
this._refreshChart();
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* The series definition information to use when charting
|
|
|
* specific fields on the chart. displayName, xField,
|
|
|
* and style members are used to construct the series
|
|
|
* definition; the "group" member is the array of fields
|
|
|
* that should be charted when the table is sorted by a
|
|
|
* given field.
|
|
|
* @attribute chartSeriesDefinitions
|
|
|
* @type obj
|
|
|
* @default See JS source for full default definitions.
|
|
|
*/
|
|
|
this.setAttributeConfig('chartSeriesDefinitions', {
|
|
|
value: attr.chartSeriesDefinitions || {
|
|
|
total: {
|
|
|
displayName: PV.STRINGS.colHeads.total[0],
|
|
|
xField: "total",
|
|
|
style: {color:"4d95dd", size:20},
|
|
|
group: ["total"]
|
|
|
},
|
|
|
calls: {
|
|
|
displayName: PV.STRINGS.colHeads.calls[0],
|
|
|
xField: "calls",
|
|
|
style: {color:"edff9f", size:20},
|
|
|
group: ["calls"]
|
|
|
},
|
|
|
avg: {
|
|
|
displayName: PV.STRINGS.colHeads.avg[0],
|
|
|
xField: "avg",
|
|
|
style: {color:"209daf", size:9},
|
|
|
group: ["avg", "min", "max"]
|
|
|
},
|
|
|
min: {
|
|
|
displayName: PV.STRINGS.colHeads.min[0],
|
|
|
xField: "min",
|
|
|
style: {color:"b6ecf4", size:9},
|
|
|
group: ["avg", "min", "max"]
|
|
|
},
|
|
|
max: {
|
|
|
displayName: PV.STRINGS.colHeads.max[0],
|
|
|
xField: "max",
|
|
|
style: {color:"29c7de", size:9},
|
|
|
group: ["avg", "min", "max"]
|
|
|
},
|
|
|
pct: {
|
|
|
displayName: PV.STRINGS.colHeads.pct[0],
|
|
|
xField: "pct",
|
|
|
style: {color:"C96EDB", size:20},
|
|
|
group: ["pct"]
|
|
|
}
|
|
|
},
|
|
|
method: function() {
|
|
|
if(this._rendered && this.get("showChart")) {
|
|
|
this._refreshChart();
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* The default visibility setting for the viewer canvas. If true,
|
|
|
* the viewer will load all necessary files and render itself
|
|
|
* immediately upon instantiation; otherwise, the viewer will
|
|
|
* load only minimal resources until the user toggles visibility
|
|
|
* via the UI.
|
|
|
* @attribute visible
|
|
|
* @type boolean
|
|
|
* @default false
|
|
|
*/
|
|
|
this.setAttributeConfig('visible', {
|
|
|
value: attr.visible || false,
|
|
|
validator: YAHOO.lang.isBoolean,
|
|
|
method: function(b) {
|
|
|
if(b) {
|
|
|
this._show();
|
|
|
} else {
|
|
|
if (this._rendered) {
|
|
|
this._hide();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
|
|
|
/**
|
|
|
* The default visibility setting for the chart.
|
|
|
* @attribute showChart
|
|
|
* @type boolean
|
|
|
* @default true
|
|
|
*/
|
|
|
this.setAttributeConfig('showChart', {
|
|
|
value: attr.showChart || true,
|
|
|
validator: YAHOO.lang.isBoolean,
|
|
|
writeOnce: true
|
|
|
|
|
|
});
|
|
|
|
|
|
YAHOO.widget.ProfilerViewer.superclass.initAttributes.call(this, attr);
|
|
|
|
|
|
YAHOO.log("Attributes initialized.", "info", "ProfilerViewer");
|
|
|
};
|
|
|
|
|
|
})();
|
|
|
YAHOO.register("profilerviewer", YAHOO.widget.ProfilerViewer, {version: "2.8.0r4", build: "2449"});
|
|
|
|
