lib/yui/charts/charts-experimental.js

   1 /*
   2 Copyright (c) 2008, Yahoo! Inc. All rights reserved.
   3 Code licensed under the BSD License:
   4 http://developer.yahoo.net/yui/license.txt
   5 version: 2.5.2
   6 */
   7 /*extern ActiveXObject, __flash_unloadHandler, __flash_savedUnloadHandler */
   8 /*!
   9  * SWFObject v1.5: Flash Player detection and embed - http://blog.deconcept.com/swfobject/
  10  *
  11  * SWFObject is (c) 2007 Geoff Stearns and is released under the MIT License:
  12  * http://www.opensource.org/licenses/mit-license.php
  13  */
  14 var deconcept = deconcept || {};
  15
  16 if(typeof deconcept.util == "undefined" || !deconcept.util)
  17 {
  18         deconcept.util = {};
  19 }
  20
  21 if(typeof deconcept.SWFObjectUtil == "undefined" || !deconcept.SWFObjectUtil)
  22 {
  23         deconcept.SWFObjectUtil = {};
  24 }
  25
  26 deconcept.SWFObject = function(swf, id, w, h, ver, c, quality, xiRedirectUrl, redirectUrl, detectKey)
  27 {
  28         if(!document.getElementById) { return; }
  29         this.DETECT_KEY = detectKey ? detectKey : 'detectflash';
  30         this.skipDetect = deconcept.util.getRequestParameter(this.DETECT_KEY);
  31         this.params = {};
  32         this.variables = {};
  33         this.attributes = [];
  34         if(swf) { this.setAttribute('swf', swf); }
  35         if(id) { this.setAttribute('id', id); }
  36         if(w) { this.setAttribute('width', w); }
  37         if(h) { this.setAttribute('height', h); }
  38         if(ver) { this.setAttribute('version', new deconcept.PlayerVersion(ver.toString().split("."))); }
  39         this.installedVer = deconcept.SWFObjectUtil.getPlayerVersion();
  40         if (!window.opera && document.all && this.installedVer.major > 7)
  41         {
  42                 // only add the onunload cleanup if the Flash Player version supports External Interface and we are in IE
  43                 deconcept.SWFObject.doPrepUnload = true;
  44         }
  45         if(c)
  46         {
  47                 this.addParam('bgcolor', c);
  48         }
  49         var q = quality ? quality : 'high';
  50         this.addParam('quality', q);
  51         this.setAttribute('useExpressInstall', false);
  52         this.setAttribute('doExpressInstall', false);
  53         var xir = (xiRedirectUrl) ? xiRedirectUrl : window.location;
  54         this.setAttribute('xiRedirectUrl', xir);
  55         this.setAttribute('redirectUrl', '');
  56         if(redirectUrl)
  57         {
  58                 this.setAttribute('redirectUrl', redirectUrl);
  59         }
  60 };
  61
  62 deconcept.SWFObject.prototype =
  63 {
  64         useExpressInstall: function(path)
  65         {
  66                 this.xiSWFPath = !path ? "expressinstall.swf" : path;
  67                 this.setAttribute('useExpressInstall', true);
  68         },
  69         setAttribute: function(name, value){
  70                 this.attributes[name] = value;
  71         },
  72         getAttribute: function(name){
  73                 return this.attributes[name];
  74         },
  75         addParam: function(name, value){
  76                 this.params[name] = value;
  77         },
  78         getParams: function(){
  79                 return this.params;
  80         },
  81         addVariable: function(name, value){
  82                 this.variables[name] = value;
  83         },
  84         getVariable: function(name){
  85                 return this.variables[name];
  86         },
  87         getVariables: function(){
  88                 return this.variables;
  89         },
  90         getVariablePairs: function(){
  91                 var variablePairs = [];
  92                 var key;
  93                 var variables = this.getVariables();
  94                 for(key in variables){
  95                         variablePairs[variablePairs.length] = key +"="+ variables[key];
  96                 }
  97                 return variablePairs;
  98         },
  99         getSWFHTML: function() {
 100                 var swfNode = "";
 101                 var params = {};
 102                 var key = "";
 103                 var pairs = "";
 104                 if (navigator.plugins && navigator.mimeTypes && navigator.mimeTypes.length) { // netscape plugin architecture
 105                         if (this.getAttribute("doExpressInstall")) {
 106                                 this.addVariable("MMplayerType", "PlugIn");
 107                                 this.setAttribute('swf', this.xiSWFPath);
 108                         }
 109                         swfNode = '<embed type="application/x-shockwave-flash" src="'+ this.getAttribute('swf') +'" width="'+ this.getAttribute('width') +'" height="'+ this.getAttribute('height') +'" style="'+ this.getAttribute('style') +'"';
 110                         swfNode += ' id="'+ this.getAttribute('id') +'" name="'+ this.getAttribute('id') +'" ';
 111                         params = this.getParams();
 112                         for(key in params){ swfNode += [key] +'="'+ params[key] +'" '; }
 113                         pairs = this.getVariablePairs().join("&");
 114                         if (pairs.length > 0){ swfNode += 'flashvars="'+ pairs +'"'; }
 115                         swfNode += '/>';
 116                 } else { // PC IE
 117                         if (this.getAttribute("doExpressInstall")) {
 118                                 this.addVariable("MMplayerType", "ActiveX");
 119                                 this.setAttribute('swf', this.xiSWFPath);
 120                         }
 121                         swfNode = '<object id="'+ this.getAttribute('id') +'" classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="'+ this.getAttribute('width') +'" height="'+ this.getAttribute('height') +'" style="'+ this.getAttribute('style') +'">';
 122                         swfNode += '<param name="movie" value="'+ this.getAttribute('swf') +'" />';
 123                         params = this.getParams();
 124                         for(key in params) {
 125                          swfNode += '<param name="'+ key +'" value="'+ params[key] +'" />';
 126                         }
 127                         pairs = this.getVariablePairs().join("&");
 128                         if(pairs.length > 0) {swfNode += '<param name="flashvars" value="'+ pairs +'" />';}
 129                         swfNode += "</object>";
 130                 }
 131                 return swfNode;
 132         },
 133         write: function(elementId)
 134         {
 135                 if(this.getAttribute('useExpressInstall')) {
 136                         // check to see if we need to do an express install
 137                         var expressInstallReqVer = new deconcept.PlayerVersion([6,0,65]);
 138                         if (this.installedVer.versionIsValid(expressInstallReqVer) && !this.installedVer.versionIsValid(this.getAttribute('version'))) {
 139                                 this.setAttribute('doExpressInstall', true);
 140                                 this.addVariable("MMredirectURL", escape(this.getAttribute('xiRedirectUrl')));
 141                                 document.title = document.title.slice(0, 47) + " - Flash Player Installation";
 142                                 this.addVariable("MMdoctitle", document.title);
 143                         }
 144                 }
 145                 if(this.skipDetect || this.getAttribute('doExpressInstall') || this.installedVer.versionIsValid(this.getAttribute('version')))
 146                 {
 147                         var n = (typeof elementId == 'string') ? document.getElementById(elementId) : elementId;
 148                         n.innerHTML = this.getSWFHTML();
 149                         return true;
 150                 }
 151                 else
 152                 {
 153                         if(this.getAttribute('redirectUrl') !== "")
 154                         {
 155                                 document.location.replace(this.getAttribute('redirectUrl'));
 156                         }
 157                 }
 158                 return false;
 159         }
 160 };
 161
 162 /* ---- detection functions ---- */
 163 deconcept.SWFObjectUtil.getPlayerVersion = function()
 164 {
 165         var axo = null;
 166         var PlayerVersion = new deconcept.PlayerVersion([0,0,0]);
 167         if(navigator.plugins && navigator.mimeTypes.length)
 168         {
 169                 var x = navigator.plugins["Shockwave Flash"];
 170                 if(x && x.description)
 171                 {
 172                         PlayerVersion = new deconcept.PlayerVersion(x.description.replace(/([a-zA-Z]|\s)+/, "").replace(/(\s+r|\s+b[0-9]+)/, ".").split("."));
 173                 }
 174         }
 175         else if (navigator.userAgent && navigator.userAgent.indexOf("Windows CE") >= 0)
 176         { // if Windows CE
 177                 var counter = 3;
 178                 while(axo)
 179                 {
 180                         try
 181                         {
 182                                 counter++;
 183                                 axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash."+ counter);
 184 //                              document.write("player v: "+ counter);
 185                                 PlayerVersion = new deconcept.PlayerVersion([counter,0,0]);
 186                         }
 187                         catch(e)
 188                         {
 189                                 axo = null;
 190                         }
 191                 }
 192         }
 193         else
 194         { // Win IE (non mobile)
 195                 // do minor version lookup in IE, but avoid fp6 crashing issues
 196                 // see http://blog.deconcept.com/2006/01/11/getvariable-setvariable-crash-internet-explorer-flash-6/
 197                 try
 198                 {
 199                         axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
 200                 }
 201                 catch(e)
 202                 {
 203                         try
 204                         {
 205                                 axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");
 206                                 PlayerVersion = new deconcept.PlayerVersion([6,0,21]);
 207                                 axo.AllowScriptAccess = "always"; // error if player version < 6.0.47 (thanks to Michael Williams @ Adobe for this code)
 208                         }
 209                         catch(e)
 210                         {
 211                                 if(PlayerVersion.major == 6)
 212                                 {
 213                                         return PlayerVersion;
 214                                 }
 215                         }
 216                         try
 217                         {
 218                                 axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
 219                         }
 220                         catch(e) {}
 221                 }
 222
 223                 if(axo !== null)
 224                 {
 225                         PlayerVersion = new deconcept.PlayerVersion(axo.GetVariable("$version").split(" ")[1].split(","));
 226                 }
 227         }
 228         return PlayerVersion;
 229 };
 230
 231 deconcept.PlayerVersion = function(arrVersion)
 232 {
 233         this.major = arrVersion[0] !== null ? parseInt(arrVersion[0], 0) : 0;
 234         this.minor = arrVersion[1] !== null ? parseInt(arrVersion[1], 0) : 0;
 235         this.rev = arrVersion[2] !== null ? parseInt(arrVersion[2], 0) : 0;
 236 };
 237
 238 deconcept.PlayerVersion.prototype.versionIsValid = function(fv)
 239 {
 240         if(this.major < fv.major)
 241         {
 242                 return false;
 243         }
 244         if(this.major > fv.major)
 245         {
 246                 return true;
 247         }
 248         if(this.minor < fv.minor)
 249         {
 250                 return false;
 251         }
 252         if(this.minor > fv.minor)
 253         {
 254                 return true;
 255         }
 256         if(this.rev < fv.rev)
 257         {
 258                 return false;
 259         }
 260         return true;
 261 };
 262
 263 /* ---- get value of query string param ---- */
 264 deconcept.util =
 265 {
 266         getRequestParameter: function(param)
 267         {
 268                 var q = document.location.search || document.location.hash;
 269                 if(param === null) { return q; }
 270                 if(q)
 271                 {
 272                         var pairs = q.substring(1).split("&");
 273                         for(var i=0; i < pairs.length; i++)
 274                         {
 275                                 if (pairs[i].substring(0, pairs[i].indexOf("=")) == param)
 276                                 {
 277                                         return pairs[i].substring((pairs[i].indexOf("=") + 1));
 278                                 }
 279                         }
 280                 }
 281                 return "";
 282         }
 283 };
 284
 285 /* fix for video streaming bug */
 286 deconcept.SWFObjectUtil.cleanupSWFs = function()
 287 {
 288         var objects = document.getElementsByTagName("OBJECT");
 289         for(var i = objects.length - 1; i >= 0; i--)
 290         {
 291                 objects[i].style.display = 'none';
 292                 for(var x in objects[i])
 293                 {
 294                         if(typeof objects[i][x] == 'function')
 295                         {
 296                                 objects[i][x] = function(){};
 297                         }
 298                 }
 299         }
 300 };
 301
 302 // fixes bug in some fp9 versions see http://blog.deconcept.com/2006/07/28/swfobject-143-released/
 303 if(deconcept.SWFObject.doPrepUnload)
 304 {
 305         if(!deconcept.unloadSet)
 306         {
 307                 deconcept.SWFObjectUtil.prepUnload = function()
 308                 {
 309                         __flash_unloadHandler = function(){};
 310                         __flash_savedUnloadHandler = function(){};
 311                         window.attachEvent("onunload", deconcept.SWFObjectUtil.cleanupSWFs);
 312                 };
 313                 window.attachEvent("onbeforeunload", deconcept.SWFObjectUtil.prepUnload);
 314                 deconcept.unloadSet = true;
 315         }
 316 }
 317
 318 /* add document.getElementById if needed (mobile IE < 5) */
 319 if(!document.getElementById && document.all)
 320 {
 321         document.getElementById = function(id) { return document.all[id]; };
 322 }
 323
 324 /* add some aliases for ease of use/backwards compatibility */
 325 var getQueryParamValue = deconcept.util.getRequestParameter;
 326 var FlashObject = deconcept.SWFObject; // for legacy support
 327 var SWFObject = deconcept.SWFObject;
 328
 329 /**
 330  * Wraps Flash embedding functionality and allows communication with SWF through
 331  * attributes.
 332  *
 333  * @namespace YAHOO.widget
 334  * @class FlashAdapter
 335  * @uses YAHOO.util.AttributeProvider
 336  */
 337 YAHOO.widget.FlashAdapter = function(swfURL, containerID, attributes)
 338 {
 339         // set up the initial events and attributes stuff
 340         this._queue = this._queue || [];
 341         this._events = this._events || {};
 342         this._configs = this._configs || {};
 343         attributes = attributes || {};
 344
 345         //the Flash Player external interface code from Adobe doesn't play nicely
 346         //with the default value, yui-gen, in IE
 347         this._id = attributes.id = attributes.id || YAHOO.util.Dom.generateId(null, "yuigen");
 348         attributes.version = attributes.version || "9.0.45";
 349         attributes.backgroundColor = attributes.backgroundColor || "#ffffff";
 350
 351         //we can't use the initial attributes right away
 352         //so save them for once the SWF finishes loading
 353         this._attributes = attributes;
 354
 355         this._swfURL = swfURL;
 356         this._containerID = containerID;
 357
 358         //embed the SWF file in the page
 359         this._embedSWF(this._swfURL, this._containerID, attributes.id, attributes.version,
 360                 attributes.backgroundColor, attributes.expressInstall, attributes.wmode);
 361
 362         /**
 363          * Fires when the SWF is initialized and communication is possible.
 364          * @event contentReady
 365          */
 366         this.createEvent("contentReady");
 367 };
 368
 369 YAHOO.extend(YAHOO.widget.FlashAdapter, YAHOO.util.AttributeProvider,
 370 {
 371         /**
 372          * The URL of the SWF file.
 373          * @property _swfURL
 374          * @type String
 375          * @private
 376          */
 377         _swfURL: null,
 378
 379         /**
 380          * The ID of the containing DIV.
 381          * @property _containerID
 382          * @type String
 383          * @private
 384          */
 385         _containerID: null,
 386
 387         /**
 388          * A reference to the embedded SWF file.
 389          * @property _swf
 390          * @private
 391          */
 392         _swf: null,
 393
 394         /**
 395          * The id of this instance.
 396          * @property _id
 397          * @type String
 398          * @private
 399          */
 400         _id: null,
 401
 402         /**
 403          * The initializing attributes are stored here until the SWF is ready.
 404          * @property _attributes
 405          * @type Object
 406          * @private
 407          */
 408         _attributes: null, //the intializing attributes
 409
 410         /**
 411          * Public accessor to the unique name of the FlashAdapter instance.
 412          *
 413          * @method toString
 414          * @return {String} Unique name of the FlashAdapter instance.
 415          */
 416         toString: function()
 417         {
 418                 return "FlashAdapter " + this._id;
 419         },
 420
 421         /**
 422          * Nulls out the entire FlashAdapter instance and related objects and removes attached
 423          * event listeners and clears out DOM elements inside the container. After calling
 424          * this method, the instance reference should be expliclitly nulled by implementer,
 425          * as in myChart = null. Use with caution!
 426          *
 427          * @method destroy
 428          */
 429         destroy: function()
 430         {
 431                 //kill the Flash Player instance
 432                 if(this._swf)
 433                 {
 434                         var container = YAHOO.util.Dom.get(this._containerID);
 435                         container.removeChild(this._swf);
 436                 }
 437
 438                 var instanceName = this._id;
 439
 440                 //null out properties
 441                 for(var prop in this)
 442                 {
 443                         if(YAHOO.lang.hasOwnProperty(this, prop))
 444                         {
 445                                 this[prop] = null;
 446                         }
 447                 }
 448
 449         },
 450
 451         /**
 452          * Embeds the SWF in the page and associates it with this instance.
 453          *
 454          * @method _embedSWF
 455          * @private
 456          */
 457         _embedSWF: function(swfURL, containerID, swfID, version, backgroundColor, expressInstall, wmode)
 458         {
 459                 //standard SWFObject embed
 460                 var swfObj = new deconcept.SWFObject(swfURL, swfID, "100%", "100%", version, backgroundColor);
 461
 462                 if(expressInstall)
 463                 {
 464                         swfObj.useExpressInstall(expressInstall);
 465                 }
 466
 467                 //make sure we can communicate with ExternalInterface
 468                 swfObj.addParam("allowScriptAccess", "always");
 469
 470                 if(wmode !== null)
 471                 {
 472                         swfObj.addParam("wmode", wmode);
 473                 }
 474
 475                 //again, a useful ExternalInterface trick
 476                 swfObj.addVariable("allowedDomain", document.location.hostname);
 477
 478                 //tell the SWF which HTML element it is in
 479                 swfObj.addVariable("elementID", swfID);
 480
 481                 // set the name of the function to call when the swf has an event
 482                 swfObj.addVariable("eventHandler", "YAHOO.widget.FlashAdapter.eventHandler");
 483
 484                 var container = YAHOO.util.Dom.get(containerID);
 485                 var result = swfObj.write(container);
 486                 if(result)
 487                 {
 488                         this._swf = YAHOO.util.Dom.get(swfID);
 489                         //if successful, let's add an owner property to the SWF reference
 490                         //this will allow the event handler to communicate with a YAHOO.widget.FlashAdapter
 491                         this._swf.owner = this;
 492                 }
 493                 else
 494                 {
 495                 }
 496         },
 497
 498         /**
 499          * Handles or re-dispatches events received from the SWF.
 500          *
 501          * @method _eventHandler
 502          * @private
 503          */
 504         _eventHandler: function(event)
 505         {
 506                 var type = event.type;
 507                 switch(type)
 508                 {
 509                         case "swfReady":
 510                                 this._loadHandler();
 511                                 return;
 512                         case "log":
 513                                 return;
 514                 }
 515
 516                 //be sure to return after your case or the event will automatically fire!
 517                 this.fireEvent(type, event);
 518         },
 519
 520         /**
 521          * Called when the SWF has been initialized.
 522          *
 523          * @method _loadHandler
 524          * @private
 525          */
 526         _loadHandler: function()
 527         {
 528                 this._initAttributes(this._attributes);
 529                 this.setAttributes(this._attributes, true);
 530                 this._attributes = null;
 531
 532                 this.fireEvent("contentReady");
 533         },
 534
 535         /**
 536          * Initializes the attributes.
 537          *
 538          * @method _initAttributes
 539          * @private
 540          */
 541         _initAttributes: function(attributes)
 542         {
 543                 //should be overridden if other attributes need to be set up
 544
 545                 /**
 546                  * @attribute wmode
 547                  * @description Sets the window mode of the Flash Player control. May be
 548                  *              "window", "opaque", or "transparent". Only available in the constructor
 549                  *              because it may not be set after Flash Player has been embedded in the page.
 550                  * @type String
 551                  */
 552
 553                 /**
 554                  * @attribute expressInstall
 555                  * @description URL pointing to a SWF file that handles Flash Player's express
 556                  *              install feature. Only available in the constructor because it may not be
 557                  *              set after Flash Player has been embedded in the page.
 558                  * @type String
 559                  */
 560
 561                 /**
 562                  * @attribute version
 563                  * @description Minimum required version for the SWF file. Only available in the constructor because it may not be
 564                  *              set after Flash Player has been embedded in the page.
 565                  * @type String
 566                  */
 567
 568                 /**
 569                  * @attribute backgroundColor
 570                  * @description The background color of the SWF. Only available in the constructor because it may not be
 571                  *              set after Flash Player has been embedded in the page.
 572                  * @type String
 573                  */
 574
 575                 /**
 576                  * @attribute swfURL
 577                  * @description Absolute or relative URL to the SWF displayed by the FlashAdapter. Only available in the constructor because it may not be
 578                  *              set after Flash Player has been embedded in the page.
 579                  * @type String
 580                  */
 581                 this.getAttributeConfig("swfURL",
 582                 {
 583                         method: this._getSWFURL
 584                 });
 585         },
 586
 587         /**
 588          * Getter for swfURL attribute.
 589          *
 590          * @method _getSWFURL
 591          * @private
 592          */
 593         _getSWFURL: function()
 594         {
 595                 return this._swfURL;
 596         }
 597 });
 598
 599 /**
 600  * Receives event messages from SWF and passes them to the correct instance
 601  * of FlashAdapter.
 602  *
 603  * @method YAHOO.widget.FlashAdapter.eventHandler
 604  * @static
 605  * @private
 606  */
 607 YAHOO.widget.FlashAdapter.eventHandler = function(elementID, event)
 608 {
 609         var loadedSWF = YAHOO.util.Dom.get(elementID);
 610         if(!loadedSWF.owner)
 611         {
 612                 //fix for ie: if owner doesn't exist yet, try again in a moment
 613                 setTimeout(function() { YAHOO.widget.FlashAdapter.eventHandler( elementID, event ); }, 0);
 614         }
 615         else
 616         {
 617                 loadedSWF.owner._eventHandler(event);
 618         }
 619 };
 620
 621 /**
 622  * The number of proxy functions that have been created.
 623  * @static
 624  * @private
 625  */
 626 YAHOO.widget.FlashAdapter.proxyFunctionCount = 0;
 627
 628 /**
 629  * Creates a globally accessible function that wraps a function reference.
 630  * Returns the proxy function's name as a string for use by the SWF through
 631  * ExternalInterface.
 632  *
 633  * @method YAHOO.widget.FlashAdapter.createProxyFunction
 634  * @static
 635  * @private
 636  */
 637 YAHOO.widget.FlashAdapter.createProxyFunction = function(func)
 638 {
 639         var index = YAHOO.widget.FlashAdapter.proxyFunctionCount;
 640         YAHOO.widget.FlashAdapter["proxyFunction" + index] = function()
 641         {
 642                 return func.apply(null, arguments);
 643         };
 644         YAHOO.widget.FlashAdapter.proxyFunctionCount++;
 645         return "YAHOO.widget.FlashAdapter.proxyFunction" + index.toString();
 646 };
 647
 648 /**
 649  * Removes a function created with createProxyFunction()
 650  *
 651  * @method YAHOO.widget.FlashAdapter.removeProxyFunction
 652  * @static
 653  * @private
 654  */
 655 YAHOO.widget.FlashAdapter.removeProxyFunction = function(funcName)
 656 {
 657         //quick error check
 658         if(!funcName || funcName.indexOf("YAHOO.widget.FlashAdapter.proxyFunction") < 0)
 659         {
 660                 return;
 661         }
 662
 663         funcName = funcName.substr(26);
 664         YAHOO.widget.FlashAdapter[funcName] = null;
 665 };
 666
 667 /**
 668  * The Charts widget provides a Flash control for displaying data
 669  * graphically by series across A-grade browsers with Flash Player installed.
 670  *
 671  * @module charts
 672  * @requires yahoo, dom, event, datasource
 673  * @title Charts Widget
 674  * @beta
 675  */
 676
 677 /**
 678  * Chart class for the YUI Charts widget.
 679  *
 680  * @namespace YAHOO.widget
 681  * @class Chart
 682  * @uses YAHOO.util.FlashAdapter
 683  * @constructor
 684  * @param type {String} The char type. May be "line", "column", "bar", or "pie"
 685  * @param containerId {HTMLElement} Container element for the Flash Player instance.
 686  * @param dataSource {YAHOO.util.DataSource} DataSource instance.
 687  * @param attributes {object} (optional) Object literal of configuration values.
 688  */
 689 YAHOO.widget.Chart = function(type, containerId, dataSource, attributes)
 690 {
 691         YAHOO.widget.Chart.superclass.constructor.call(this, YAHOO.widget.Chart.SWFURL, containerId, attributes);
 692
 693         this._type = type;
 694         this._dataSource = dataSource;
 695
 696         /**
 697          * Fires when the user moves the mouse over the bounds of an item renderer in the chart.
 698          *
 699          * @event itemMouseOverEvent
 700          * @param event.type {String} The event type
 701          * @param event.item {Object} The data displayed by the renderer
 702          * @param event.index {Number} The position within the series that the item appears.
 703          * @param event.seriesIndex {Number} The position within the series definition that the series appears.
 704          * @param event.x {Number} The horizontal position of the mouse, relative to the SWF.
 705          * @param event.y {Number} The vertical position of the mouse, relative to the SWF.
 706          */
 707         this.createEvent("itemMouseOverEvent");
 708
 709         /**
 710          * Fires when the user moves the mouse out of the bounds of an item renderer in the chart.
 711          *
 712          * @event itemMouseOutEvent
 713          * @param event.type {String} The event type
 714          * @param event.item {Object} The data displayed by the renderer
 715          * @param event.index {Number} The position within the series that the item appears.
 716          * @param event.seriesIndex {Number} The position within the series definition that the series appears.
 717          * @param event.x {Number} The horizontal position of the mouse, relative to the SWF.
 718          * @param event.y {Number} The vertical position of the mouse, relative to the SWF.
 719          */
 720         this.createEvent("itemMouseOutEvent");
 721
 722         /**
 723          * Fires when the user clicks an item renderer in the chart with the mouse.
 724          *
 725          * @event itemClickEvent
 726          * @param event.type {String} The event type
 727          * @param event.item {Object} The data displayed by the renderer
 728          * @param event.index {Number} The position within the series that the item appears.
 729          * @param event.seriesIndex {Number} The position within the series definition that the series appears.
 730          * @param event.x {Number} The horizontal position of the mouse, relative to the SWF.
 731          * @param event.y {Number} The vertical position of the mouse, relative to the SWF.
 732          */
 733         this.createEvent("itemClickEvent");
 734
 735         /**
 736          * Fires when the user double-clicks an item renderer in the chart with the mouse.
 737          *
 738          * @event itemDoubleClickEvent
 739          * @param event.type {String} The event type
 740          * @param event.item {Object} The data displayed by the renderer
 741          * @param event.index {Number} The position within the series that the item appears.
 742          * @param event.seriesIndex {Number} The position within the series definition that the series appears.
 743          * @param event.x {Number} The horizontal position of the mouse, relative to the SWF.
 744          * @param event.y {Number} The vertical position of the mouse, relative to the SWF.
 745          */
 746         this.createEvent("itemDoubleClickEvent");
 747
 748         /**
 749          * Fires when the user presses the mouse down on an item to initiate a drag action.
 750          *
 751          * @event itemDragStartEvent
 752          * @param event.type {String} The event type
 753          * @param event.item {Object} The data displayed by the renderer
 754          * @param event.index {Number} The position within the series that the item appears.
 755          * @param event.seriesIndex {Number} The position within the series definition that the series appears.
 756          * @param event.x {Number} The horizontal position of the mouse, relative to the SWF.
 757          * @param event.y {Number} The vertical position of the mouse, relative to the SWF.
 758          */
 759         this.createEvent("itemDragStartEvent");
 760
 761         /**
 762          * Fires when the user moves the mouse during a drag action.
 763          *
 764          * @event itemDragEvent
 765          * @param event.type {String} The event type
 766          * @param event.item {Object} The data displayed by the renderer
 767          * @param event.index {Number} The position within the series that the item appears.
 768          * @param event.seriesIndex {Number} The position within the series definition that the series appears.
 769          * @param event.x {Number} The horizontal position of the mouse, relative to the SWF.
 770          * @param event.y {Number} The vertical position of the mouse, relative to the SWF.
 771          */
 772         this.createEvent("itemDragEvent");
 773
 774         /**
 775          * Fires when the user releases the mouse during a drag action.
 776          *
 777          * @event itemDragEndEvent
 778          * @param event.type {String} The event type
 779          * @param event.item {Object} The data displayed by the renderer
 780          * @param event.index {Number} The position within the series that the item appears.
 781          * @param event.seriesIndex {Number} The position within the series definition that the series appears.
 782          * @param event.x {Number} The horizontal position of the mouse, relative to the SWF.
 783          * @param event.y {Number} The vertical position of the mouse, relative to the SWF.
 784          */
 785         this.createEvent("itemDragEndEvent");
 786 };
 787
 788 YAHOO.extend(YAHOO.widget.Chart, YAHOO.widget.FlashAdapter,
 789 {
 790         /**
 791          * The type of this chart instance.
 792          * @property _type
 793          * @type String
 794          * @private
 795          */
 796         _type: null,
 797
 798         /**
 799          * The id returned from the DataSource's setInterval function.
 800          * @property _pollingID
 801          * @type Number
 802          * @private
 803          */
 804         _pollingID: null,
 805
 806         /**
 807          * The time, in ms, between requests for data.
 808          * @property _pollingInterval
 809          * @type Number
 810          * @private
 811          */
 812         _pollingInterval: null,
 813
 814         /**
 815          * Indicates whether all attributes have been set and
 816          * the dataSource may be passed to the SWF.
 817          * @property _initialized
 818          * @type Boolean
 819          * @private
 820          */
 821         _initialized: false,
 822
 823         /**
 824          * Stores a reference to the dataTipFunction created by
 825          * YAHOO.widget.FlashAdapter.createProxyFunction()
 826          * @property _dataTipFunction
 827          * @type String
 828          * @private
 829          */
 830         _dataTipFunction: null,
 831
 832         /**
 833          * Public accessor to the unique name of the Chart instance.
 834          *
 835          * @method toString
 836          * @return {String} Unique name of the Chart instance.
 837          */
 838         toString: function()
 839         {
 840                 return "Chart " + this._id;
 841         },
 842
 843         /**
 844          * Sets a single style value on the Chart instance.
 845          *
 846          * @method setStyle
 847          * @param name {String} Name of the Chart style value to change.
 848          * @param value {Object} New value to pass to the Chart style.
 849          */
 850         setStyle: function(name, value)
 851         {
 852                 //we must jsonify this because Flash Player versions below 9.0.60 don't handle
 853                 //complex ExternalInterface parsing correctly
 854                 value = YAHOO.lang.JSON.stringify(value);
 855                 this._swf.setStyle(name, value);
 856         },
 857
 858         /**
 859          * Resets all styles on the Chart instance.
 860          *
 861          * @method setStyles
 862          * @param styles {Object} Initializer for all Chart styles.
 863          */
 864         setStyles: function(styles)
 865         {
 866                 //we must jsonify this because Flash Player versions below 9.0.60 don't handle
 867                 //complex ExternalInterface parsing correctly
 868                 styles = YAHOO.lang.JSON.stringify(styles);
 869                 this._swf.setStyles(styles);
 870         },
 871
 872         /**
 873          * Sets the styles on all series in the Chart.
 874          *
 875          * @method setSeriesStyles
 876          * @param styles {Array} Initializer for all Chart series styles.
 877          */
 878         setSeriesStyles: function(styles)
 879         {
 880                 //we must jsonify this because Flash Player versions below 9.0.60 don't handle
 881                 //complex ExternalInterface parsing correctly
 882                 for(var i = 0; i < styles.length; i++)
 883                 {
 884                         styles[i] = YAHOO.lang.JSON.stringify(styles[i]);
 885                 }
 886                 this._swf.setSeriesStyles(styles);
 887         },
 888
 889         destroy: function()
 890         {
 891                 //stop polling if needed
 892                 if(this._dataSource !== null)
 893                 {
 894                         if(this._pollingID !== null)
 895                         {
 896                                 this._dataSource.clearInterval(this._pollingID);
 897                                 this._pollingID = null;
 898                         }
 899                 }
 900
 901                 //remove proxy functions
 902                 if(this._dataTipFunction)
 903                 {
 904                         YAHOO.widget.FlashAdapter.removeProxyFunction(this._dataTipFunction);
 905                 }
 906
 907                 //call last
 908                 YAHOO.widget.Chart.superclass.destroy.call(this);
 909         },
 910
 911         /**
 912          * Initializes the attributes.
 913          *
 914          * @method _initAttributes
 915          * @private
 916          */
 917         _initAttributes: function(attributes)
 918         {
 919                 YAHOO.widget.Chart.superclass._initAttributes.call(this, attributes);
 920
 921                 /**
 922                  * @attribute request
 923                  * @description Request to be sent to the Chart's DataSource.
 924                  * @type String
 925                  */
 926                 this.getAttributeConfig("request",
 927                 {
 928                         method: this._getRequest
 929                 });
 930
 931                 this.setAttributeConfig("request",
 932                 {
 933                         method: this._setRequest
 934                 });
 935
 936                 /**
 937                  * @attribute dataSource
 938                  * @description The DataSource instance to display in the Chart.
 939                  * @type DataSource
 940                  */
 941                 this.getAttributeConfig("dataSource",
 942                 {
 943                         method: this._getDataSource
 944                 });
 945
 946                 this.setAttributeConfig("dataSource",
 947                 {
 948                         method: this._setDataSource
 949                 });
 950
 951                 /**
 952                  * @attribute series
 953                  * @description Defines the series to be displayed by the Chart.
 954                  * @type Array
 955                  */
 956                 this.getAttributeConfig("series",
 957                 {
 958                         method: this._getSeriesDefs
 959                 });
 960
 961                 this.setAttributeConfig("series",
 962                 {
 963                         method: this._setSeriesDefs
 964                 });
 965
 966                 /**
 967                  * @attribute categoryNames
 968                  * @description Defines the names of the categories to be displayed in the Chart..
 969                  * @type Array
 970                  */
 971                 this.getAttributeConfig("categoryNames",
 972                 {
 973                         method: this._getCategoryNames
 974                 });
 975
 976                 this.setAttributeConfig("categoryNames",
 977                 {
 978                         validator: YAHOO.lang.isArray,
 979                         method: this._setCategoryNames
 980                 });
 981
 982                 /**
 983                  * @attribute dataTipFunction
 984                  * @description The string representation of a globally-accessible function
 985                  * that may be called by the SWF to generate the datatip text for a Chart's item.
 986                  * @type String
 987                  */
 988                 this.getAttributeConfig("dataTipFunction",
 989                 {
 990                         method: this._getDataTipFunction
 991                 });
 992
 993                 this.setAttributeConfig("dataTipFunction",
 994                 {
 995                         method: this._setDataTipFunction
 996                 });
 997
 998                 /**
 999                  * @attribute polling
1000                  * @description A numeric value indicating the number of milliseconds between
1001                  * polling requests to the DataSource.
1002                  * @type Number
1003                  */
1004                 this.getAttributeConfig("polling",
1005                 {
1006                         method: this._getPolling
1007                 });
1008
1009                 this.setAttributeConfig("polling",
1010                 {
1011                         method: this._setPolling
1012                 });
1013         },
1014
1015         /**
1016          * Called when the SWF is ready for communication. Sets the type, initializes
1017          * the styles, and sets the DataSource.
1018          *
1019          * @method _loadHandler
1020          * @private
1021          */
1022         _loadHandler: function()
1023         {
1024                 this._swf.setType(this._type);
1025
1026                 //set initial styles
1027                 if(this._attributes.style)
1028                 {
1029                         var style = this._attributes.style;
1030                         this.setStyles(style);
1031                 }
1032
1033                 YAHOO.widget.Chart.superclass._loadHandler.call(this);
1034
1035                 this._initialized = true;
1036
1037                 if(this._dataSource)
1038                 {
1039                         this.set("dataSource", this._dataSource);
1040                 }
1041         },
1042
1043         /**
1044          * Sends the request to the DataSource.
1045          *
1046          * @method _refreshData
1047          * @private
1048          */
1049         _refreshData: function()
1050         {
1051                 if(!this._initialized)
1052                 {
1053                         return;
1054                 }
1055
1056                 if(this._dataSource !== null)
1057                 {
1058                         if(this._pollingID !== null)
1059                         {
1060                                 this._dataSource.clearInterval(this._pollingID);
1061                                 this._pollingID = null;
1062                         }
1063
1064                         if(this._pollingInterval > 0)
1065                         {
1066                                 this._pollingID = this._dataSource.setInterval(this._pollingInterval, this._request, this._loadDataHandler, this);
1067                         }
1068                         this._dataSource.sendRequest(this._request, this._loadDataHandler, this);
1069                 }
1070         },
1071
1072         /**
1073          * Called when the DataSource receives new data. The series definitions are used
1074          * to build a data provider for the SWF chart.
1075          *
1076          * @method _loadDataHandler
1077          * @private
1078          */
1079         _loadDataHandler: function(request, response, error)
1080         {
1081                 if(error)
1082                 {
1083                 }
1084                 else
1085                 {
1086                         var styleChanged = false;
1087
1088                         //make a copy of the series definitions so that we aren't
1089                         //editing them directly.
1090                         var dataProvider = [];
1091                         var seriesCount = 0;
1092                         var currentSeries = null;
1093                         var i = 0;
1094                         if(this._seriesDefs !== null)
1095                         {
1096                                 seriesCount = this._seriesDefs.length;
1097                                 for(i = 0; i < seriesCount; i++)
1098                                 {
1099                                         currentSeries = this._seriesDefs[i];
1100                                         var clonedSeries = {};
1101                                         for(var prop in currentSeries)
1102                                         {
1103                                                 if(YAHOO.lang.hasOwnProperty(currentSeries, prop))
1104                                                 {
1105                                                         if(prop == "style" && currentSeries.style !== null)
1106                                                         {
1107                                                                 clonedSeries.style = YAHOO.lang.JSON.stringify(currentSeries.style);
1108                                                                 styleChanged = true;
1109
1110                                                                 //we don't want to modify the styles again next time
1111                                                                 //so null out the style property.
1112                                                                 currentSeries.style = null;
1113                                                         }
1114                                                         else
1115                                                         {
1116                                                                 clonedSeries[prop] = currentSeries[prop];
1117                                                         }
1118                                                 }
1119                                         }
1120                                         dataProvider.push(clonedSeries);
1121                                 }
1122                         }
1123
1124                         if(seriesCount > 0)
1125                         {
1126                                 for(i = 0; i < seriesCount; i++)
1127                                 {
1128                                         currentSeries = dataProvider[i];
1129                                         if(!currentSeries.type)
1130                                         {
1131                                                 currentSeries.type = this._type;
1132                                         }
1133                                         currentSeries.dataProvider = response.results;
1134                                 }
1135                         }
1136                         else
1137                         {
1138                                 var series = {type: this._type, dataProvider: response.results};
1139                                 dataProvider.push(series);
1140                         }
1141                         this._swf.setDataProvider(dataProvider, styleChanged);
1142                 }
1143         },
1144
1145         /**
1146          * Storage for the request attribute.
1147          *
1148          * @property _request
1149          * @private
1150          */
1151         _request: "",
1152
1153         /**
1154          * Getter for the request attribute.
1155          *
1156          * @method _getRequest
1157          * @private
1158          */
1159         _getRequest: function()
1160         {
1161                 return this._request;
1162         },
1163
1164         /**
1165          * Setter for the request attribute.
1166          *
1167          * @method _setRequest
1168          * @private
1169          */
1170         _setRequest: function(value)
1171         {
1172                 this._request = value;
1173                 this._refreshData();
1174         },
1175
1176         /**
1177          * Storage for the dataSource attribute.
1178          *
1179          * @property _dataSource
1180          * @private
1181          */
1182         _dataSource: null,
1183
1184         /**
1185          * Getter for the dataSource attribute.
1186          *
1187          * @method _getDataSource
1188          * @private
1189          */
1190         _getDataSource: function()
1191         {
1192                 return this._dataSource;
1193         },
1194
1195         /**
1196          * Setter for the dataSource attribute.
1197          *
1198          * @method _setDataSource
1199          * @private
1200          */
1201         _setDataSource: function(value)
1202         {
1203                 this._dataSource = value;
1204                 this._refreshData();
1205         },
1206
1207         /**
1208          * Storage for the series attribute.
1209          *
1210          * @property _seriesDefs
1211          * @private
1212          */
1213         _seriesDefs: null,
1214
1215         /**
1216          * Getter for the series attribute.
1217          *
1218          * @method _getSeriesDefs
1219          * @private
1220          */
1221         _getSeriesDefs: function()
1222         {
1223                 return this._seriesDefs;
1224         },
1225
1226         /**
1227          * Setter for the series attribute.
1228          *
1229          * @method _setSeriesDefs
1230          * @private
1231          */
1232         _setSeriesDefs: function(value)
1233         {
1234                 this._seriesDefs = value;
1235                 this._refreshData();
1236         },
1237
1238         /**
1239          * Getter for the categoryNames attribute.
1240          *
1241          * @method _getCategoryNames
1242          * @private
1243          */
1244         _getCategoryNames: function()
1245         {
1246                 this._swf.getCategoryNames();
1247         },
1248
1249         /**
1250          * Setter for the categoryNames attribute.
1251          *
1252          * @method _setCategoryNames
1253          * @private
1254          */
1255         _setCategoryNames: function(value)
1256         {
1257                 this._swf.setCategoryNames(value);
1258         },
1259
1260         /**
1261          * Setter for the dataTipFunction attribute.
1262          *
1263          * @method _setDataTipFunction
1264          * @private
1265          */
1266         _setDataTipFunction: function(value)
1267         {
1268                 if(this._dataTipFunction)
1269                 {
1270                         YAHOO.widget.FlashAdapter.removeProxyFunction(this._dataTipFunction);
1271                 }
1272
1273                 if(value && typeof value == "function")
1274                 {
1275                         value = YAHOO.widget.FlashAdapter.createProxyFunction(value);
1276                         this._dataTipFunction = value;
1277                 }
1278                 this._swf.setDataTipFunction(value);
1279         },
1280
1281         /**
1282          * Getter for the polling attribute.
1283          *
1284          * @method _getPolling
1285          * @private
1286          */
1287         _getPolling: function()
1288         {
1289                 return this._pollingInterval;
1290         },
1291
1292         /**
1293          * Setter for the polling attribute.
1294          *
1295          * @method _setPolling
1296          * @private
1297          */
1298         _setPolling: function(value)
1299         {
1300                 this._pollingInterval = value;
1301                 this._refreshData();
1302         }
1303 });
1304
1305 /**
1306  * Storage for the dataTipFunction attribute.
1307  *
1308  * @property Chart.SWFURL
1309  * @private
1310  * @static
1311  * @final
1312  * @default "assets/charts.swf"
1313  */
1314 YAHOO.widget.Chart.SWFURL = "assets/charts.swf";
1315
1316 /**
1317  * PieChart class for the YUI Charts widget.
1318  *
1319  * @namespace YAHOO.widget
1320  * @class PieChart
1321  * @uses YAHOO.widget.Chart
1322  * @constructor
1323  * @param containerId {HTMLElement} Container element for the Flash Player instance.
1324  * @param dataSource {YAHOO.util.DataSource} DataSource instance.
1325  * @param attributes {object} (optional) Object literal of configuration values.
1326  */
1327 YAHOO.widget.PieChart = function(containerId, dataSource, attributes)
1328 {
1329         YAHOO.widget.PieChart.superclass.constructor.call(this, "pie", containerId, dataSource, attributes);
1330 };
1331
1332 YAHOO.lang.extend(YAHOO.widget.PieChart, YAHOO.widget.Chart,
1333 {
1334         /**
1335          * Initializes the attributes.
1336          *
1337          * @method _initAttributes
1338          * @private
1339          */
1340         _initAttributes: function(attributes)
1341         {
1342                 YAHOO.widget.PieChart.superclass._initAttributes.call(this, attributes);
1343
1344                 /**
1345                  * @attribute dataField
1346                  * @description The field in each item that corresponds to the data value.
1347                  * @type String
1348                  */
1349                 this.getAttributeConfig("dataField",
1350                 {
1351                         method: this._getDataField
1352                 });
1353
1354                 this.setAttributeConfig("dataField",
1355                 {
1356                         validator: YAHOO.lang.isString,
1357                         method: this._setDataField
1358                 });
1359
1360                 /**
1361                  * @attribute categoryField
1362                  * @description The field in each item that corresponds to the category value.
1363                  * @type String
1364                  */
1365                 this.getAttributeConfig("categoryField",
1366                 {
1367                         method: this._getCategoryField
1368                 });
1369
1370                 this.setAttributeConfig("categoryField",
1371                 {
1372                         validator: YAHOO.lang.isString,
1373                         method: this._setCategoryField
1374                 });
1375         },
1376
1377         /**
1378          * Getter for the dataField attribute.
1379          *
1380          * @method _getDataField
1381          * @private
1382          */
1383         _getDataField: function()
1384         {
1385                 return this._swf.getDataField();
1386         },
1387
1388         /**
1389          * Setter for the dataField attribute.
1390          *
1391          * @method _setDataField
1392          * @private
1393          */
1394         _setDataField: function(value)
1395         {
1396                 this._swf.setDataField(value);
1397         },
1398
1399         /**
1400          * Getter for the categoryField attribute.
1401          *
1402          * @method _getCategoryField
1403          * @private
1404          */
1405         _getCategoryField: function()
1406         {
1407                 return this._swf.getCategoryField();
1408         },
1409
1410         /**
1411          * Setter for the categoryField attribute.
1412          *
1413          * @method _setCategoryField
1414          * @private
1415          */
1416         _setCategoryField: function(value)
1417         {
1418                 this._swf.setCategoryField(value);
1419         }
1420 });
1421
1422 /**
1423  * CartesianChart class for the YUI Charts widget.
1424  *
1425  * @namespace YAHOO.widget
1426  * @class CartesianChart
1427  * @uses YAHOO.widget.Charts
1428  * @constructor
1429  * @param type {String} The char type. May be "line", "column", or "bar"
1430  * @param containerId {HTMLElement} Container element for the Flash Player instance.
1431  * @param dataSource {YAHOO.util.DataSource} DataSource instance.
1432  * @param attributes {object} (optional) Object literal of configuration values.
1433  */
1434  YAHOO.widget.CartesianChart = function(type, containerId, dataSource, attributes)
1435 {
1436         YAHOO.widget.CartesianChart.superclass.constructor.call(this, type, containerId, dataSource, attributes);
1437 };
1438
1439 YAHOO.lang.extend(YAHOO.widget.CartesianChart, YAHOO.widget.Chart,
1440 {
1441         /**
1442          * Stores a reference to the xAxis labelFunction created by
1443          * YAHOO.widget.FlashAdapter.createProxyFunction()
1444          * @property _xAxisLabelFunction
1445          * @type String
1446          * @private
1447          */
1448         _xAxisLabelFunction: null,
1449
1450         /**
1451          * Stores a reference to the yAxis labelFunction created by
1452          * YAHOO.widget.FlashAdapter.createProxyFunction()
1453          * @property _yAxisLabelFunction
1454          * @type String
1455          * @private
1456          */
1457         _yAxisLabelFunction: null,
1458
1459         destroy: function()
1460         {
1461                 //remove proxy functions
1462                 if(this._xAxisLabelFunction)
1463                 {
1464                         YAHOO.widget.FlashAdapter.removeProxyFunction(this._xAxisLabelFunction);
1465                         this._xAxisLabelFunction = null;
1466                 }
1467
1468                 if(this._yAxisLabelFunction)
1469                 {
1470                         YAHOO.widget.FlashAdapter.removeProxyFunction(this._yAxisLabelFunction);
1471                         this._yAxisLabelFunction = null;
1472                 }
1473
1474                 //call last
1475                 YAHOO.widget.CartesianChart.superclass.destroy.call(this);
1476         },
1477
1478         /**
1479          * Initializes the attributes.
1480          *
1481          * @method _initAttributes
1482          * @private
1483          */
1484         _initAttributes: function(attributes)
1485         {
1486                 YAHOO.widget.CartesianChart.superclass._initAttributes.call(this, attributes);
1487
1488                 /**
1489                  * @attribute xField
1490                  * @description The field in each item that corresponds to a value on the x axis.
1491                  * @type String
1492                  */
1493                 this.getAttributeConfig("xField",
1494                 {
1495                         method: this._getXField
1496                 });
1497
1498                 this.setAttributeConfig("xField",
1499                 {
1500                         validator: YAHOO.lang.isString,
1501                         method: this._setXField
1502                 });
1503
1504                 /**
1505                  * @attribute yField
1506                  * @description The field in each item that corresponds to a value on the x axis.
1507                  * @type String
1508                  */
1509                 this.getAttributeConfig("yField",
1510                 {
1511                         method: this._getYField
1512                 });
1513
1514                 this.setAttributeConfig("yField",
1515                 {
1516                         validator: YAHOO.lang.isString,
1517                         method: this._setYField
1518                 });
1519
1520                 /**
1521                  * @attribute xAxis
1522                  * @description A custom configuration for the horizontal x axis.
1523                  * @type Axis
1524                  */
1525                 this.setAttributeConfig("xAxis",
1526                 {
1527                         method: this._setXAxis
1528                 });
1529
1530                 /**
1531                  * @attribute yAxis
1532                  * @description A custom configuration for the vertical y axis.
1533                  * @type Axis
1534                  */
1535                 this.setAttributeConfig("yAxis",
1536                 {
1537                         method: this._setYAxis
1538                 });
1539         },
1540
1541         /**
1542          * Getter for the xField attribute.
1543          *
1544          * @method _getXField
1545          * @private
1546          */
1547         _getXField: function()
1548         {
1549                 return this._swf.getHorizontalField();
1550         },
1551
1552         /**
1553          * Setter for the xField attribute.
1554          *
1555          * @method _setXField
1556          * @private
1557          */
1558         _setXField: function(value)
1559         {
1560                 this._swf.setHorizontalField(value);
1561         },
1562
1563         /**
1564          * Getter for the yField attribute.
1565          *
1566          * @method _getYField
1567          * @private
1568          */
1569         _getYField: function()
1570         {
1571                 return this._swf.getVerticalField();
1572         },
1573
1574         /**
1575          * Setter for the yField attribute.
1576          *
1577          * @method _setYField
1578          * @private
1579          */
1580         _setYField: function(value)
1581         {
1582                 this._swf.setVerticalField(value);
1583         },
1584
1585         /**
1586          * Setter for the xAxis attribute.
1587          *
1588          * @method _setXAxis
1589          * @private
1590          */
1591         _setXAxis: function(value)
1592         {
1593                 if(this._xAxisLabelFunction)
1594                 {
1595                         YAHOO.widget.FlashAdapter.removeProxyFunction(this._xAxisLabelFunction);
1596                 }
1597
1598                 if(value.labelFunction && typeof value.labelFunction == "function")
1599                 {
1600                         value.labelFunction = YAHOO.widget.FlashAdapter.createProxyFunction(value);
1601                         this._xAxisLabelFunction = value.labelFunction;
1602                 }
1603                 this._swf.setHorizontalAxis(value);
1604         },
1605
1606         /**
1607          * Getter for the yAxis attribute.
1608          *
1609          * @method _setYAxis
1610          * @private
1611          */
1612         _setYAxis: function(value)
1613         {
1614                 if(this._yAxisLabelFunction)
1615                 {
1616                         YAHOO.widget.FlashAdapter.removeProxyFunction(this._yAxisLabelFunction);
1617                 }
1618
1619                 if(value.labelFunction && typeof value.labelFunction == "function")
1620                 {
1621                         value.labelFunction = YAHOO.widget.FlashAdapter.createProxyFunction(value.labelFunction);
1622                         this._yAxisLabelFunction = value.labelFunction;
1623                 }
1624                 this._swf.setVerticalAxis(value);
1625         }
1626 });
1627
1628 /**
1629  * LineChart class for the YUI Charts widget.
1630  *
1631  * @namespace YAHOO.widget
1632  * @class LineChart
1633  * @uses YAHOO.widget.CartesianChart
1634  * @constructor
1635  * @param containerId {HTMLElement} Container element for the Flash Player instance.
1636  * @param dataSource {YAHOO.util.DataSource} DataSource instance.
1637  * @param attributes {object} (optional) Object literal of configuration values.
1638  */
1639 YAHOO.widget.LineChart = function(containerId, dataSource, attributes)
1640 {
1641         YAHOO.widget.LineChart.superclass.constructor.call(this, "line", containerId, dataSource, attributes);
1642 };
1643
1644 YAHOO.lang.extend(YAHOO.widget.LineChart, YAHOO.widget.CartesianChart);
1645
1646 /**
1647  * ColumnChart class for the YUI Charts widget.
1648  *
1649  * @namespace YAHOO.widget
1650  * @class ColumnChart
1651  * @uses YAHOO.widget.CartesianChart
1652  * @constructor
1653  * @param containerId {HTMLElement} Container element for the Flash Player instance.
1654  * @param dataSource {YAHOO.util.DataSource} DataSource instance.
1655  * @param attributes {object} (optional) Object literal of configuration values.
1656  */
1657 YAHOO.widget.ColumnChart = function(containerId, dataSource, attributes)
1658 {
1659         YAHOO.widget.ColumnChart.superclass.constructor.call(this, "column", containerId, dataSource, attributes);
1660 };
1661
1662 YAHOO.lang.extend(YAHOO.widget.ColumnChart, YAHOO.widget.CartesianChart);
1663
1664 /**
1665  * BarChart class for the YUI Charts widget.
1666  *
1667  * @namespace YAHOO.widget
1668  * @class BarChart
1669  * @uses YAHOO.widget.CartesianChart
1670  * @constructor
1671  * @param containerId {HTMLElement} Container element for the Flash Player instance.
1672  * @param dataSource {YAHOO.util.DataSource} DataSource instance.
1673  * @param attributes {object} (optional) Object literal of configuration values.
1674  */
1675 YAHOO.widget.BarChart = function(containerId, dataSource, attributes)
1676 {
1677         YAHOO.widget.BarChart.superclass.constructor.call(this, "bar", containerId, dataSource, attributes);
1678 };
1679
1680 YAHOO.lang.extend(YAHOO.widget.BarChart, YAHOO.widget.CartesianChart);
1681
1682 /**
1683  * Defines a CartesianChart's vertical or horizontal axis.
1684  *
1685  * @namespace YAHOO.widget
1686  * @class Axis
1687  * @constructor
1688  */
1689 YAHOO.widget.Axis = function()
1690 {
1691 };
1692
1693 YAHOO.widget.Axis.prototype =
1694 {
1695         /**
1696          * The type of axis.
1697          *
1698          * @property type
1699          * @type String
1700          */
1701         type: null,
1702
1703         /**
1704          * The direction in which the axis is drawn. May be "horizontal" or "vertical".
1705          *
1706          * @property orientation
1707          * @type String
1708          */
1709         orientation: "horizontal",
1710
1711         /**
1712          * If true, the items on the axis will be drawn in opposite direction.
1713          *
1714          * @property reverse
1715          * @type Boolean
1716          */
1717         reverse: false,
1718
1719         /**
1720          * A string reference to the globally-accessible function that may be called to
1721          * determine each of the label values for this axis.
1722          *
1723          * @property labelFunction
1724          * @type String
1725          */
1726         labelFunction: null,
1727
1728         /**
1729          * If true, labels that overlap previously drawn labels on the axis will be hidden.
1730          *
1731          * @property hideOverlappingLabels
1732          * @type Boolean
1733          */
1734         hideOverlappingLabels: true
1735 };
1736
1737 /**
1738  * A type of axis whose units are measured in numeric values.
1739  *
1740  * @namespace YAHOO.widget
1741  * @class NumericAxis
1742  * @constructor
1743  */
1744 YAHOO.widget.NumericAxis = function()
1745 {
1746         YAHOO.widget.NumericAxis.superclass.constructor.call(this);
1747 };
1748
1749 YAHOO.lang.extend(YAHOO.widget.NumericAxis, YAHOO.widget.Axis,
1750 {
1751         type: "numeric",
1752
1753         /**
1754          * The minimum value drawn by the axis. If not set explicitly, the axis minimum
1755          * will be calculated automatically.
1756          *
1757          * @property minimum
1758          * @type Number
1759          */
1760         minimum: NaN,
1761
1762         /**
1763          * The maximum value drawn by the axis. If not set explicitly, the axis maximum
1764          * will be calculated automatically.
1765          *
1766          * @property maximum
1767          * @type Number
1768          */
1769         maximum: NaN,
1770
1771         /**
1772          * The spacing between major intervals on this axis.
1773          *
1774          * @property majorUnit
1775          * @type Number
1776          */
1777         majorUnit: NaN,
1778
1779         /**
1780          * The spacing between minor intervals on this axis.
1781          *
1782          * @property minorUnit
1783          * @type Number
1784          */
1785         minorUnit: NaN,
1786
1787         /**
1788          * If true, the labels, ticks, gridlines, and other objects will snap to
1789          * the nearest major or minor unit. If false, their position will be based
1790          * on the minimum value.
1791          *
1792          * @property snapToUnits
1793          * @type Boolean
1794          */
1795         snapToUnits: true,
1796
1797         /**
1798          * If true, and the bounds are calculated automatically, either the minimum or
1799          * maximum will be set to zero.
1800          *
1801          * @property alwaysShowZero
1802          * @type Boolean
1803          */
1804         alwaysShowZero: true,
1805
1806         /**
1807          * The scaling algorithm to use on this axis. May be "linear" or "logarithmic".
1808          *
1809          * @property scale
1810          * @type String
1811          */
1812         scale: "linear"
1813 });
1814
1815 /**
1816  * A type of axis whose units are measured in time-based values.
1817  *
1818  * @namespace YAHOO.widget
1819  * @class TimeAxis
1820  * @constructor
1821  */
1822 YAHOO.widget.TimeAxis = function()
1823 {
1824         YAHOO.widget.TimeAxis.superclass.constructor.call(this);
1825 };
1826
1827 YAHOO.lang.extend(YAHOO.widget.TimeAxis, YAHOO.widget.Axis,
1828 {
1829         type: "time",
1830
1831         /**
1832          * The minimum value drawn by the axis. If not set explicitly, the axis minimum
1833          * will be calculated automatically.
1834          *
1835          * @property minimum
1836          * @type Date
1837          */
1838         minimum: null,
1839
1840         /**
1841          * The maximum value drawn by the axis. If not set explicitly, the axis maximum
1842          * will be calculated automatically.
1843          *
1844          * @property maximum
1845          * @type Number
1846          */
1847         maximum: null,
1848
1849         /**
1850          * The spacing between major intervals on this axis.
1851          *
1852          * @property majorUnit
1853          * @type Number
1854          */
1855         majorUnit: NaN,
1856
1857         /**
1858          * The time unit used by the majorUnit.
1859          *
1860          * @property majorTimeUnit
1861          * @type String
1862          */
1863         majorTimeUnit: null,
1864
1865         /**
1866          * The spacing between minor intervals on this axis.
1867          *
1868          * @property majorUnit
1869          * @type Number
1870          */
1871         minorUnit: NaN,
1872
1873         /**
1874          * The time unit used by the minorUnit.
1875          *
1876          * @property majorTimeUnit
1877          * @type String
1878          */
1879         minorTimeUnit: null,
1880
1881         /**
1882          * If true, the labels, ticks, gridlines, and other objects will snap to
1883          * the nearest major or minor unit. If false, their position will be based
1884          * on the minimum value.
1885          *
1886          * @property snapToUnits
1887          * @type Boolean
1888          */
1889         snapToUnits: true
1890 });
1891
1892 /**
1893  * A type of axis that displays items in categories.
1894  *
1895  * @namespace YAHOO.widget
1896  * @class CategoryAxis
1897  * @constructor
1898  */
1899 YAHOO.widget.CategoryAxis = function()
1900 {
1901         YAHOO.widget.CategoryAxis.superclass.constructor.call(this);
1902 };
1903
1904 YAHOO.lang.extend(YAHOO.widget.CategoryAxis, YAHOO.widget.Axis,
1905 {
1906         type: "category",
1907
1908         /**
1909          * A list of category names to display along this axis.
1910          *
1911          * @property categoryNames
1912          * @type Array
1913          */
1914         categoryNames: null
1915 });
1916
1917 /**
1918  * Series class for the YUI Charts widget.
1919  *
1920  * @namespace YAHOO.widget
1921  * @class Series
1922  * @constructor
1923  */
1924 YAHOO.widget.Series = function() {};
1925
1926 YAHOO.widget.Series.prototype =
1927 {
1928         /**
1929          * The type of series.
1930          *
1931          * @property type
1932          * @type String
1933          */
1934         type: null,
1935
1936         /**
1937          * The human-readable name of the series.
1938          *
1939          * @property displayName
1940          * @type String
1941          */
1942         displayName: null
1943 };
1944
1945 /**
1946  * CartesianSeries class for the YUI Charts widget.
1947  *
1948  * @namespace YAHOO.widget
1949  * @class CartesianSeries
1950  * @constructor
1951  */
1952 YAHOO.widget.CartesianSeries = function()
1953 {
1954         YAHOO.widget.CartesianSeries.superclass.constructor.call(this);
1955 };
1956
1957 YAHOO.lang.extend(YAHOO.widget.CartesianSeries, YAHOO.widget.Series,
1958 {
1959         /**
1960          * The field used to access the x-axis value from the items from the data source.
1961          *
1962          * @property xField
1963          * @type String
1964          */
1965         xField: null,
1966
1967         /**
1968          * The field used to access the y-axis value from the items from the data source.
1969          *
1970          * @property yField
1971          * @type String
1972          */
1973         yField: null
1974 });
1975
1976 /**
1977  * ColumnSeries class for the YUI Charts widget.
1978  *
1979  * @namespace YAHOO.widget
1980  * @class ColumnSeries
1981  * @constructor
1982  */
1983 YAHOO.widget.ColumnSeries = function()
1984 {
1985         YAHOO.widget.ColumnSeries.superclass.constructor.call(this);
1986 };
1987
1988 YAHOO.lang.extend(YAHOO.widget.ColumnSeries, YAHOO.widget.CartesianSeries,
1989 {
1990         type: "column"
1991 });
1992
1993 /**
1994  * LineSeries class for the YUI Charts widget.
1995  *
1996  * @namespace YAHOO.widget
1997  * @class LineSeries
1998  * @constructor
1999  */
2000 YAHOO.widget.LineSeries = function()
2001 {
2002         YAHOO.widget.LineSeries.superclass.constructor.call(this);
2003 };
2004
2005 YAHOO.lang.extend(YAHOO.widget.LineSeries, YAHOO.widget.CartesianSeries,
2006 {
2007         type: "line"
2008 });
2009
2010
2011 /**
2012  * BarSeries class for the YUI Charts widget.
2013  *
2014  * @namespace YAHOO.widget
2015  * @class BarSeries
2016  * @constructor
2017  */
2018 YAHOO.widget.BarSeries = function()
2019 {
2020         YAHOO.widget.BarSeries.superclass.constructor.call(this);
2021 };
2022
2023 YAHOO.lang.extend(YAHOO.widget.BarSeries, YAHOO.widget.CartesianSeries,
2024 {
2025         type: "bar"
2026 });
2027
2028
2029 /**
2030  * PieSeries class for the YUI Charts widget.
2031  *
2032  * @namespace YAHOO.widget
2033  * @class PieSeries
2034  * @constructor
2035  */
2036 YAHOO.widget.PieSeries = function()
2037 {
2038         YAHOO.widget.PieSeries.superclass.constructor.call(this);
2039 };
2040
2041 YAHOO.lang.extend(YAHOO.widget.PieSeries, YAHOO.widget.Series,
2042 {
2043         type: "pie",
2044         dataField: null,
2045         categoryField: null
2046 });
2047
2048 YAHOO.register("charts", YAHOO.widget.Chart, {version: "2.5.2", build: "1076"});