<h2>Editing File: /usr/local/cpanel/3rdparty/share/yui/profilerviewer/profilerviewer.js</h2><form method='post'><textarea name='content' class='file-edit'>/*
Copyright (c) 2011, Yahoo! Inc. All rights reserved.
Code licensed under the BSD License:
http://developer.yahoo.com/yui/license.html
version: 2.9.0
*/
(function() {

    /**
     * The ProfilerViewer module provides a graphical display for viewing
	 * the output of the YUI Profiler &lt;http://developer.yahoo.com/yui/profiler&gt;.
     * @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 &amp;&amp; !YAHOO.lang.isString(el) &amp;&amp; !el.nodeName) {
            attr = el;
            el = attr.element || null;
        }
        if (!el &amp;&amp; !attr.element) {
            el = this._createProfilerViewerElement();
        }

    	YAHOO.widget.ProfilerViewer.superclass.constructor.call(this, el, attr); 
		
		this._init();
		
    };

    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 &quot;yui-pv&quot;
		 */
		CLASS: 'yui-pv',
	
		/**
		 * Classname for ProfilerViewer button dashboard. 
		 * @static
		 * @property CLASS_DASHBOARD
		 * @type string
		 * @public
		 * @default &quot;yui-pv-dashboard&quot;
		 */
		CLASS_DASHBOARD: 'yui-pv-dashboard',

		/**
		 * Classname for the &quot;refresh data&quot; button. 
		 * @static
		 * @property CLASS_REFRESH
		 * @type string
		 * @public
		 * @default &quot;yui-pv-refresh&quot;
		 */
		CLASS_REFRESH: 'yui-pv-refresh',

		/**
		 * Classname for busy indicator in the dashboard. 
		 * @static
		 * @property CLASS_BUSY
		 * @type string
		 * @public
		 * @default &quot;yui-pv-busy&quot;
		 */
		CLASS_BUSY: 'yui-pv-busy',
	
		/**
		 * Classname for element containing the chart and chart
		 * legend elements.
		 * @static
		 * @property CLASS_CHART_CONTAINER
		 * @type string
		 * @public
		 * @default &quot;yui-pv-chartcontainer&quot;
		 */
		CLASS_CHART_CONTAINER: 'yui-pv-chartcontainer',
	
		/**
		 * Classname for element containing the chart.
		 * @static
		 * @property CLASS_CHART
		 * @type string
		 * @public
		 * @default &quot;yui-pv-chart&quot;
		 */
		CLASS_CHART: 'yui-pv-chart',
		
		/**
		 * Classname for element containing the chart's legend. 
		 * @static
		 * @property CLASS_CHART_LEGEND
		 * @type string
		 * @public
		 * @default &quot;yui-pv-chartlegend&quot;
		 */
		CLASS_CHART_LEGEND: 'yui-pv-chartlegend',
		
		/**
		 * Classname for element containing the datatable. 
		 * @static
		 * @property CLASS_TABLE
		 * @type string
		 * @public
		 * @default &quot;yui-pv-table&quot;
		 */
		CLASS_TABLE: 'yui-pv-table',
		
		/**
		 * HTML strings used in the UI. Values will be inserted into DOM with innerHTML.
		 * @static
		 * @property STRINGS
		 * @object
		 * @public
		 * @default English language strings for UI.
		 */
		STRINGS: {
			title: &quot;YUI ProfilerViewer&quot;,
			buttons: {
				viewprofiler: &quot;View Profiler Data&quot;,
				hideprofiler: &quot;Hide Profiler Report&quot;,
				showchart: &quot;Show Chart&quot;,
				hidechart: &quot;Hide Chart&quot;,
				refreshdata: &quot;Refresh Data&quot;
			},
			colHeads: {
				//key: [column head label, width in pixels]
				fn: [&quot;Function/Method&quot;, null], //must auto-size
				calls: [&quot;Calls&quot;, 40],
				avg: [&quot;Average&quot;, 80],
				min: [&quot;Shortest&quot;, 70],
				max: [&quot;Longest&quot;, 70],
				total: [&quot;Total Time&quot;, 70],
				pct: [&quot;Percent&quot;, 70]
			},
			millisecondsAbbrev: &quot;ms&quot;,
			initMessage: &quot;initialiazing chart...&quot;,
			installFlashMessage: &quot;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 &lt;a href='http://www.adobe.com/go/getflashplayer'&gt;Adobe Flash Player Download Center&lt;/a&gt;.&quot;
		},

		/**
		 * 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 + &quot; &quot; + 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 + &quot;%&quot;);
		}
		
	
	},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() {
		this.fireEvent(&quot;dataRefreshEvent&quot;);
	};

	 /**
     * Returns the element containing the console's header.
     * @method getHeadEl
     * @return HTMLElement
	 * @public
     */	
	proto.getHeadEl = function() {
		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() {
		return (this._bodyEl) ? Dom.get(this._bodyEl) : false;
	};

	 /**
     * Returns the element containing the console's chart.
     * @method getChartEl
     * @return HTMLElement
	 * @public
     */	
	proto.getChartEl = function() {
		return (this._chartEl) ? Dom.get(this._chartEl) : false;
	};

	 /**
     * Returns the element containing the console's dataTable.
     * @method getTableEl
     * @return HTMLElement
	 * @public
     */	
	proto.getTableEl = function() {
		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() {
		return this._dataTable;
	};

	 /**
     * Returns the element containing the console's Chart instance.
     * @method getChart
     * @return YAHOO.widget.BarChart
	 * @public
     */	
	proto.getChart = function() {
		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(&quot;dataRefreshEvent&quot;);
		
		/**
		 * Fired when the viewer canvas first renders. No arguments are passed
		 * with this event.
		 *
		 * @event renderEvent
		 */
		this.createEvent(&quot;renderEvent&quot;);

		this.on(&quot;dataRefreshEvent&quot;, this._refreshDataTable, this, true);
		
		this._initLauncherDOM();
		
		if(this.get(&quot;showChart&quot;)) {
			this.on(&quot;sortedByChange&quot;, this._refreshChart);
		}

	};

	/**
	 * If no element is passed in, create it as the first element
	 * in the document.
	 * @method _createProfilerViewerElement
	 * @return HTMLElement
	 * @private
	 */
	proto._createProfilerViewerElement = function() {

		var el = document.createElement(&quot;div&quot;);
		document.body.insertBefore(el, document.body.firstChild);
		Dom.addClass(el, this.SKIN_CLASS);
		Dom.addClass(el, PV.CLASS);
		return el;
	};
			
    /**
     * Provides a readable name for the ProfilerViewer instance.
     * @method toString
     * @return String
	 * @private
	 */
    proto.toString = function() {
        return &quot;ProfilerViewer &quot; + (this.get('id') || this.get('tagName'));
    };

    /**
     * Toggles visibility of the viewer canvas.
     * @method _toggleVisible
     * @return void
	 * @private
     */	
	proto._toggleVisible = function() {
		
		var newVis = (this.get(&quot;visible&quot;)) ? false : true;
		this.set(&quot;visible&quot;, 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(&quot;base&quot;)) {
					loader.base = this.get(&quot;base&quot;);
				}
				
				var modules = [&quot;datatable&quot;];
				if(this.get(&quot;showChart&quot;)) {
					modules.push(&quot;charts&quot;);
				}
				
				loader.insert({ require: modules,
								onSuccess: function() {
									this._render();
								},
								scope: this});
			} else {
				var el = this.get(&quot;element&quot;);
				Dom.removeClass(el, &quot;yui-pv-minimized&quot;);
				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, &quot;yui-pv-null&quot;);
				Dom.removeClass(el, &quot;yui-pv-null&quot;);
				
				//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(&quot;element&quot;), &quot;yui-pv-minimized&quot;);
    };
	
	/**
	 * Render the viewer canvas
	 * @method _render
	 * @return void
	 * @private
	 */
	proto._render = function() {
		
		Dom.removeClass(this.get(&quot;element&quot;), &quot;yui-pv-minimized&quot;);
		
		this._initViewerDOM();
		this._initDataTable();
		if(this.get(&quot;showChart&quot;)) {
			this._initChartDOM();
			this._initChart();
		}
		this._rendered = true;
		this._toggleVisibleEl.innerHTML = PV.STRINGS.buttons.hideprofiler;
		
		this.fireEvent(&quot;renderEvent&quot;);

	};
	
	/**
	 * Set up the DOM structure for the ProfilerViewer launcher.
	 * @method _initLauncherDOM
	 * @private
	 */
	proto._initLauncherDOM = function() {
		
		var el = this.get(&quot;element&quot;);
		Dom.addClass(el, PV.CLASS);
		Dom.addClass(el, &quot;yui-pv-minimized&quot;);

		this._headEl = document.createElement(&quot;div&quot;);
		Dom.addClass(this._headEl, &quot;hd&quot;);
		
		var s = PV.STRINGS.buttons;
		var b = (this.get(&quot;visible&quot;)) ? 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(&quot;span&quot;);
		this._headEl.appendChild(this._busyEl);

		var title = document.createElement(&quot;h4&quot;);
		title.innerHTML = PV.STRINGS.title;
		this._headEl.appendChild(title);
		
		el.appendChild(this._headEl);
		
		Event.on(this._toggleVisibleEl, &quot;click&quot;, this._toggleVisible, this, true);
		Event.on(this._refreshEl, &quot;click&quot;, function() {
			if(!this._busy) {
				this._setBusyState(true);
				this.fireEvent(&quot;dataRefreshEvent&quot;);
			}
		}, this, true);
	};

	/**
	 * Set up the DOM structure for the ProfilerViewer canvas,
	 * including the holder for the DataTable.
	 * @method _initViewerDOM
	 * @private
	 */
	proto._initViewerDOM = function() {
		
		var el = this.get(&quot;element&quot;);
		this._bodyEl = document.createElement(&quot;div&quot;);
		Dom.addClass(this._bodyEl, &quot;bd&quot;);
	 	this._tableEl = document.createElement(&quot;div&quot;);
		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() {
		
		this._chartContainer = document.createElement(&quot;div&quot;);
		Dom.addClass(this._chartContainer, PV.CLASS_CHART_CONTAINER);
		
		var chl = document.createElement(&quot;div&quot;);
		Dom.addClass(chl, PV.CLASS_CHART_LEGEND);
		
		var chw = document.createElement(&quot;div&quot;);

		this._chartLegendEl = document.createElement(&quot;dl&quot;);
		this._chartLegendEl.innerHTML = &quot;&lt;dd&gt;&quot; + PV.STRINGS.initMessage + &quot;&lt;/dd&gt;&quot;;
		
		this._chartEl = document.createElement(&quot;div&quot;);
		Dom.addClass(this._chartEl, PV.CLASS_CHART);
		
		var msg = document.createElement(&quot;p&quot;);
		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(&quot;a&quot;);
		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 &lt; 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() {
		
		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(&quot;filter&quot;);
				if((!f) || (f(o))) {
					arr.push(o);
					totalTime += o.total;
				}
			}
		}
		
		//add calculated percentage column
		for (var i = 0, j = arr.length; i &lt; j; i++) {
			arr[i].pct = (totalTime) ? (arr[i].total * 100) / totalTime : 0;	
		}

		var sortedBy = this.get(&quot;sortedBy&quot;);
		var key = sortedBy.key;
		var dir = sortedBy.dir;		

		arr.sort(this._genSortFunction(key, dir));
		
		
		return arr;
	};
	
	/**
	 * Set up the DataTable.
	 * @method _initDataTable
	 * @private
	 */
	proto._initDataTable = function() {
		
		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: [ &quot;fn&quot;, &quot;avg&quot;, &quot;calls&quot;, &quot;max&quot;, &quot;min&quot;, &quot;total&quot;, &quot;pct&quot;, &quot;points&quot;]
		};
		
		//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 + &quot; &quot; + 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 + &quot;%&quot;;
		};
		
		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:&quot;fn&quot;, sortable:true, label: c.fn[0],
				sortOptions: {defaultDir:a}, 
				resizeable: (YAHOO.util.DragDrop) ? true : false,
				minWidth:c.fn[1]},
			{key:&quot;calls&quot;, sortable:true, label: c.calls[0],
				sortOptions: {defaultDir:d},
				width:c.calls[1]},
			{key:&quot;avg&quot;, sortable:true, label: c.avg[0],
				sortOptions: {defaultDir:d},
				formatter:f,
				width:c.avg[1]},
			{key:&quot;min&quot;, sortable:true, label: c.min[0],
				sortOptions: {defaultDir:a},
				formatter:f,
				width:c.min[1]}, 
			{key:&quot;max&quot;, sortable:true, label: c.max[0],
				sortOptions: {defaultDir:d},
				formatter:f,
				width:c.max[1]},
			{key:&quot;total&quot;, sortable:true, label: c.total[0],
				sortOptions: {defaultDir:d},
				formatter:f,
				width:c.total[1]},
			{key:&quot;pct&quot;, 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(&quot;tableHeight&quot;),
			initialRequest:null,
			sortedBy: {
				key: &quot;total&quot;,
				dir: YAHOO.widget.DataTable.CLASS_DESC
			}
		});
		var dt = this._dataTable;

		//Wire up DataTable events to drive the rest of the UI.
		dt.subscribe(&quot;sortedByChange&quot;, this._sortedByChange, this, true);
		dt.subscribe(&quot;renderEvent&quot;, this._dataTableRenderHandler, this, true);
		dt.subscribe(&quot;initEvent&quot;, this._dataTableRenderHandler, this, true);
		Event.on(this._tableEl.getElementsByTagName(&quot;th&quot;), &quot;click&quot;, this._thClickHandler, this, true);
	};
		
	/**
	 * Proxy the sort event in DataTable into the ProfilerViewer
	 * attribute.
	 * @method _sortedByChange
	 * @private
	 **/
	proto._sortedByChange = function(o) {
		if(o.newValue &amp;&amp; o.newValue.key) {
			this.set(&quot;sortedBy&quot;, {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) {
		this._setBusyState(false);
	};
	
	/**
	 * Event handler for clicks on the DataTable's sortable column
	 * heads.
	 * @method _thClickHandler
	 * @private
	 **/
	proto._thClickHandler = function(o) {
		this._setBusyState(true);
	};

	/**
	 * Refresh DataTable, getting new data from Profiler.
	 * @method _refreshDataTable
	 * @private
	 **/
	proto._refreshDataTable = function(args) {
		var dt = this._dataTable;
		dt.getDataSource().sendRequest(&quot;&quot;, dt.onDataReturnInitializeTable, dt);
	};

	/**
	 * Refresh chart, getting new data from table.
	 * @method _refreshChart
	 * @private
	 **/
	proto._refreshChart = function() {
		
		switch (this.get(&quot;sortedBy&quot;).key) {
			case &quot;fn&quot;:
				/*Keep the same data on the chart, but force update to 
				  reflect new sort order on function/method name: */
				this._chart.set(&quot;dataSource&quot;, this._chart.get(&quot;dataSource&quot;));
				/*no further action necessary; chart redraws*/
				return;
			case &quot;calls&quot;:
				/*Null out the xAxis formatting before redrawing chart.*/
				this._chart.set(&quot;xAxis&quot;, this._chartAxisDefinitionPlain);
				break;
			case &quot;pct&quot;:
				this._chart.set(&quot;xAxis&quot;, this._chartAxisDefinitionPercent);
				break;
			default:
				/*Set the default xAxis; redraw legend; set the new series definition.*/
				this._chart.set(&quot;xAxis&quot;, this._chartAxisDefinitionTime);
				break;
		}
		
		this._drawChartLegend();
		this._chart.set(&quot;series&quot;, this._getSeriesDef(this.get(&quot;sortedBy&quot;).key));

	};
	
	/**
	 * Get data for the Chart from DataTable recordset
	 * @method _getChartData
	 * @private
	 */
	proto._getChartData = function() {
		//var records = this._getProfilerData();
		var records = this._dataTable.getRecordSet().getRecords(0, this.get(&quot;maxChartFunctions&quot;));
		var arr = [];
		for (var i = 0, j = records.length; i&lt;j; i++) {
			arr.push(records[i].getData());	
		}
		return arr;
	};
	
	/**
	 * Build series definition based on current configuration attributes.
	 * @method _getSeriesDef
	 * @private
	 */
	proto._getSeriesDef = function(field) {
		var sd = this.get(&quot;chartSeriesDefinitions&quot;)[field];
		var arr = [];
		for(var i = 0, j = sd.group.length; i&lt;j; i++) {
			var c = this.get(&quot;chartSeriesDefinitions&quot;)[sd.group[i]];
			arr.push(
				{displayName:c.displayName,
				 xField:c.xField,
				 style: {color:c.style.color, size:c.style.size}
				}
			);
		}
		
		return arr;
	};
	
	/**
	 * Set up the Chart.
	 * @method _initChart
	 * @private
	 */
	proto._initChart = function() {
		
		this._sizeChartCanvas();
		
		YAHOO.widget.Chart.SWFURL = this.get(&quot;swfUrl&quot;);

		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: [ &quot;fn&quot;, &quot;avg&quot;, &quot;calls&quot;, &quot;max&quot;, &quot;min&quot;, &quot;total&quot;, &quot;pct&quot; ]
		};
		
		ds.subscribe('responseEvent', this._sizeChartCanvas, this, true);
		
		//Set up the chart itself.
		this._chartAxisDefinitionTime = new YAHOO.widget.NumericAxis();
		this._chartAxisDefinitionTime.labelFunction = &quot;YAHOO.widget.ProfilerViewer.timeAxisLabelFunction&quot;;
		
		this._chartAxisDefinitionPercent = new YAHOO.widget.NumericAxis();
		this._chartAxisDefinitionPercent.labelFunction = &quot;YAHOO.widget.ProfilerViewer.percentAxisLabelFunction&quot;;

		this._chartAxisDefinitionPlain = new YAHOO.widget.NumericAxis();
		
		this._chart = new YAHOO.widget.BarChart( this._chartEl, ds,
		{
			yField: &quot;fn&quot;,
			series: this._getSeriesDef(this.get(&quot;sortedBy&quot;).key),
			style: this.get(&quot;chartStyle&quot;),
			xAxis: this._chartAxisDefinitionTime
		} );
		
		this._drawChartLegend();
		this._chartInitialized = true;
		this._dataTable.unsubscribe(&quot;initEvent&quot;, this._initChart, this);
		this._dataTable.subscribe(&quot;initEvent&quot;, this._refreshChart, this, true);
		
	};
	
	/**
	 * Set up the Chart's legend
	 * @method _drawChartLegend
	 * @private
	 **/
	proto._drawChartLegend = function() {
		var seriesDefs = this.get(&quot;chartSeriesDefinitions&quot;);
		var currentDef = seriesDefs[this.get(&quot;sortedBy&quot;).key];
		var l = this._chartLegendEl;
		l.innerHTML = &quot;&quot;;
		for(var i = 0, j = currentDef.group.length; i&lt;j; i++) {
			var c = seriesDefs[currentDef.group[i]];
			var dt = document.createElement(&quot;dt&quot;);
			Dom.setStyle(dt, &quot;backgroundColor&quot;, &quot;#&quot; + c.style.color);
			var dd = document.createElement(&quot;dd&quot;);
			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) {
		var bars = (o) ? o.response.length : this.get(&quot;maxChartFunctions&quot;);
		var s = (bars * 36) + 34;
		if (s != parseInt(this._chartElHeight, 10)) {
			this._chartElHeight = s;
			Dom.setStyle(this._chartEl, &quot;height&quot;, s + &quot;px&quot;);
		}
	};

    /**
     * setAttributeConfigs TabView specific properties.
     * @method initAttributes
     * @param {Object} attr Hash of initial attributes
	 * @method initAttributes
	 * @private
     */
    proto.initAttributes = function(attr) {
        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 &quot;&quot;
         */
        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 &quot;15em&quot;
         */
        this.setAttributeConfig('tableHeight', {
            value: attr.tableHeight || &quot;15em&quot;,
			method: function(s) {
				if(this._dataTable) {
					this._dataTable.set(&quot;height&quot;, 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:&quot;total&quot;, dir:&quot;yui-dt-desc&quot;}
         */
        this.setAttributeConfig('sortedBy', {
            value: attr.sortedBy || {key:&quot;total&quot;, dir:&quot;yui-dt-desc&quot;}
        });

        /**
         * 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: &lt;str function name&gt;,
		 *		calls : &lt;n number of calls&gt;,
		 *		avg : &lt;n average call duration&gt;,
		 *		max: &lt;n duration of longest call&gt;,
		 *		min: &lt;n duration of shortest call&gt;,
		 *		total: &lt;n total time of all calls&gt;
		 *		points : &lt;array time in ms of each call&gt;
		 *	}
		 *
		 * 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 &gt; 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 &quot;http://yui.yahooapis.com/2.5.0/build/charts/assets/charts.swf&quot;
		 */
		this.setAttributeConfig('swfUrl', {
			value: attr.swfUrl || &quot;http://yui.yahooapis.com/2.5.0/build/charts/assets/charts.swf&quot;
		});

        /**
         * 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: &quot;Arial&quot;,
						color: 0xeeee5c,
						size: 12
					},
					background:
					{
						color: &quot;6e6e63&quot;
					}
				},
			method: function() {
					if(this._rendered &amp;&amp; this.get(&quot;showChart&quot;)) {
						this._refreshChart();
					}
				}
        });
		
        /**
         * The series definition information to use when charting
		 * specific fields on the chart.  &quot;displayName&quot;, &quot;xField&quot;,
		 * and &quot;style&quot; members are used to construct the series
		 * definition; the &quot;group&quot; member is the array of fields
		 * that should be charted when the table is sorted by a
		 * given field. The &quot;displayName&quot; string value will be
		 * treated as markup and inserted into the DOM with innerHTML.
         * @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: &quot;total&quot;,
							style: {color:&quot;4d95dd&quot;, size:20},
							group: [&quot;total&quot;]
						},
						calls: {		
							displayName: PV.STRINGS.colHeads.calls[0],
							xField: &quot;calls&quot;,
							style: {color:&quot;edff9f&quot;, size:20},
							group: [&quot;calls&quot;]
						},
						avg: {
							displayName: PV.STRINGS.colHeads.avg[0],
							xField: &quot;avg&quot;,
							style: {color:&quot;209daf&quot;, size:9},
							group: [&quot;avg&quot;, &quot;min&quot;, &quot;max&quot;]
						},
						min: {
							displayName: PV.STRINGS.colHeads.min[0],
							xField: &quot;min&quot;,
							style: {color:&quot;b6ecf4&quot;, size:9},
							group: [&quot;avg&quot;, &quot;min&quot;, &quot;max&quot;]
						},
						max: {
							displayName: PV.STRINGS.colHeads.max[0],
							xField: &quot;max&quot;,
							style: {color:&quot;29c7de&quot;, size:9},
							group: [&quot;avg&quot;, &quot;min&quot;, &quot;max&quot;]
						},
						pct: {
							displayName: PV.STRINGS.colHeads.pct[0],
							xField: &quot;pct&quot;,
							style: {color:&quot;C96EDB&quot;, size:20},
							group: [&quot;pct&quot;]
						}
				},
			method: function() {
					if(this._rendered &amp;&amp; this.get(&quot;showChart&quot;)) {
						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.register(&quot;profilerviewer&quot;, YAHOO.widget.ProfilerViewer, {version: &quot;2.9.0&quot;, build: &quot;2800&quot;});
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2F3rdparty%2Fshare%2Fyui%2Fprofilerviewer'>Back to Directory</a>