[Summary view] [Print] [Text view]

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