dataFunction:Function  [read-write]

Specifies a method that returns the value that should be used for positioning the current chart item in the series. If this property is set, the return value of the custom data function takes precedence over the other related properties such as xField and yField for AreaSeries, BarSeries, BubbleSeries, ColumnSeries, LineSeries and PlotSeries. For BubbleSeries, the return value takes precedence over the radiusField property. For PieSeries, the return value takes precedence over the field property.

The custom dataFunction for a series has the following signature:

     function_name (series:Series, item:Object, fieldName:String):Object { ... }
     

series is the current series that uses this dataFunction. item is the item in the data provider. fieldName is the field in current ChartItem that is to be populated. This function returns an object.

You typically use the dataFunction to access fields in a data provider that are not scalar values, but are instead nested in the data provider. For exemplo, the following data requires a dataFunction to access the fields for a chart's data provider:

      {month: "Aug", close: {High:45.87,Low:12.2}, open:25.19}
      

The following exemplo dataFunction returns a value from this data provider:

     public function myDataFunction(series:Series,item:Object,fieldName:String):Object {
          if(fieldName == 'yValue')
              return(item.close.High);
          else if(fieldName == "xValue")
              return(item.month);
          else
              return null;
     }     
     

Implementação
    public function get dataFunction():Function
    public function set dataFunction(value:Function):void

dataTipItems:Array  [read-write]

Array of chart items for which data tips are to be shown non-interactively on the chart

Implementação
    public function get dataTipItems():Array
    public function set dataTipItems(value:Array):void

dataTransform:DataTransform  [write-only]

The DataTransform object that the element is associated with. A DataTransform object represents an association between a set of elements and a set of axis objects used to transform those elements from data space to screen coordinates and back. A chart element uses its associated DataTransform object to calculate how to render its data.

Implementação
    public function set dataTransform(value:DataTransform):void

displayName:String  [read-write]

The name of the series, for display to the user. This property is used to represent the series in user-visible labels, such as DataTips.

Implementação
    public function get displayName():String
    public function set displayName(value:String):void

filterData:Boolean  [read-write]

This property is true if the series filters its data before displaying. If a series renders data that contains missing values (such as null, undefined, or NaN), or renders values outside the range of the chart axes, this property should be set to true (the default). If you know that all of the data in the series is valid, you can set this to false to improve performance

Implementação
    public function get filterData():Boolean
    public function set filterData(value:Boolean):void

interactive:Boolean  [read-write]

Determines whether DataTips appear when users interact with chart data on the screen. Set to false to prevent the series from showing DataTips or generating hitData.

The default value is true.

Implementação
    public function get interactive():Boolean
    public function set interactive(value:Boolean):void

items:Array  [read-only]

Gets all the items that are there in the series after filtering.

Individual series determine the list of items that are to be returned.

Implementação
    public function get items():Array

legendData:Array  [read-only]

An Array of LegendData instances that describe the items that should show up in a legend representing this series. Derived series classes override this getter and return LegendData specific to their styles and data representation method. While most series types return only a single LegendData instance, some series types, such as PieSeries and StackedSeries, return multiple instances representing individual items in the array, or multiple ways of rendering data.

Implementação
    public function get legendData():Array

renderData:Object  [read-only]

Stores the information necessary to render this series.

Implementação
    protected function get renderData():Object

selectable:Boolean  [read-write]

Specifies whether a series is selectable or not.

The default value is true.

Implementação
    public function get selectable():Boolean
    public function set selectable(value:Boolean):void

selectedIndex:int  [read-write]

Index of the selected item in the series' data provider. If multiple items are selected, then this property refers to the most recently selected item.

Implementação
    public function get selectedIndex():int
    public function set selectedIndex(value:int):void

selectedIndices:Array  [read-write]

An Array of indices of the selected items in the series' data provider.

Implementação
    public function get selectedIndices():Array
    public function set selectedIndices(value:Array):void

selectedItem:ChartItem  [read-write]

The chart item that is selected in the series. If there are multiple items selected, then this property refers to the most recently selected item.

Implementação
    public function get selectedItem():ChartItem
    public function set selectedItem(value:ChartItem):void

selectedItems:Array  [read-write]

An Array of chart items that are selected in the series.

Implementação
    public function get selectedItems():Array
    public function set selectedItems(value:Array):void

transitionRenderData:Object  [read-write]

A render data structure passed in by a running transtion. When a series effect is set to play on a series, it first captures the current state of the series by asking for its render data. The transition modifies the render data to create the desired effect, and passes the structure back to the series for display. If the transitionRenderData property is non-null, a series uses its contents to update its display.

Implementação
    public function get transitionRenderData():Object
    public function set transitionRenderData(value:Object):void

public function Series()

Constructor.

public function beginInterpolation(sourceRenderData:Object, destRenderData:Object):Object

Called by the SeriesInterpolate effect to initiate an interpolation. The effect passes in the source and destination data for the series to interpolate between. The effect passes the return value of this method repeatedly to the series's interpolate() method to advance the animation of the duration of the effect. The series calculates the data it needs to perform the interpolation and returns it in this method.

Parâmetros

	sourceRenderData:Object — The source data for the series to interpolate between.
	destRenderData:Object — The destination data for the series to interpolate between.

Retorna

Object — The data the series needs to perform the interpolation.

protected function cacheDefaultValues(measureName:String, cache:Array, fieldName:String):Boolean

Caches the values stored in the measureName property from the original dataProvider items in the chart item's fieldName property. If the measureName property is null or the empty string, it assumes the original dataProvider items are raw values and caches them instead.

Parâmetros

	measureName:String
	cache:Array
	fieldName:String

Retorna

Boolean

protected function cacheIndexValues(measureName:String, cache:Array, fieldName:String):Boolean

Caches the values stored in the measureName property from the original dataProvider items in the chart item's fieldName property. If the measureName property is null or the empty string, it stores the index of the items in the fieldName property instead.

Parâmetros

	measureName:String
	cache:Array
	fieldName:String

Retorna

Boolean

protected function cacheNamedValues(measureName:String, cache:Array, fieldName:String):Boolean

Caches the values stored in the measureName property from the original dataProvider items in the chart item's fieldName property.

Parâmetros

	measureName:String
	cache:Array
	fieldName:String

Retorna

Boolean

public override function claimStyles(styles:Array, firstAvailable:uint):uint

Parâmetros

	styles:Array
	firstAvailable:uint

Retorna

uint

protected override function commitProperties():void

Processes the properties set on the component. This is an advanced method that you might override when creating a subclass of UIComponent.

You do not call this method directly. Flex calls the commitProperties() method when you use the addChild() method to add a component to a container, or when you call the invalidateProperties() method of the component. Calls to the commitProperties() method occur before calls to the measure() method. This lets you set property values that might be used by the measure() method.

Some components have properties that affect the number or kinds of child objects that they need to create, or have properties that interact with each other, such as the horizontalScrollPolicy and horizontalScrollPosition properties. It is often best at startup time to process all of these properties at one time to avoid duplicating work.

public function endInterpolation(interpolationData:Object):void

Called by the SeriesInterpolate effect to end an interpolation. The effect uses this method to complete the interpolation and clean up any temporary state associated with the effect.

Parâmetros

interpolationData:Object

protected function extractMinInterval(cache:Array, measureName:String, desc:DataDescrição):void

Extracts the minimum value, maximum value, and, optionally, the minimum interval from an array of ChartItems. Derived classes can call this method from their DescribeData implementations to fill in the details of the DataDescrição structure.

Parâmetros

	cache:Array
	measureName:String
	desc:DataDescrição

protected function extractMinMax(cache:Array, measureName:String, desc:DataDescrição, calculateInterval:Boolean = false):void

Extracts the minimum value, maximum value, and, optionally, the minimum interval from an array of ChartItems. Derived classes can call this method from their DescribeData implementations to fill in the details of the DataDescrição structure.

Parâmetros

	cache:Array
	measureName:String
	desc:DataDescrição
	calculateInterval:Boolean (default = false)

public function getAxis(dimension:String):IAxis

Retrieves the Axis instance for a particular dimension of the chart. This is a low level accessor. You typically retrieve the Axis directly through a named property (such as for a cartesian based series horizontalAxis, verticalAxis, or radiusAxis).

Parâmetros

dimension:String

Retorna

IAxis

public function getElementBounds(renderData:Object):void

Fills in the elementBounds, bounds, and visibleBounds properties of a renderData structure generated by this series. Effect classes call this function to fill in these fields for use in implementing various effect types. Derived classes should implement this function to generate the bounds of the series's items only when requested.

Parâmetros

renderData:Object

public function getItemsInRegion(r:Rectangle):Array

Gets all the items that are there in a rectangular region for the series. Call this function to determine what items are under a particular rectangular region in that series.

Individual series determine whether their chart item is under the region. The point should be in the global coordinate space.

Parâmetros

r:Rectangle — A Rectangle that defines the region.

Retorna

Array — An Array of ChartItems that are within the specified rectangular region.

Veja também

protected function getMissingInterpolationValues(sourceProps:Object, srcCache:Array, destProps:Object, destCache:Array, index:Number, customData:Object):void

Fills in missing values in an interpolation structure. When a series calls the initializeInterpolationData() method, it passes in an Array of source and destination values for the interpolation. If either of those two Arrays are incomplete, the series needs to provide "appropriate" placeholder values for the interpolation. How those placeholder values are determined is specific to the series type. Series extenders should override this method to provide those placeholder values.

Parâmetros

	sourceProps:Object — An object containing the source values being interpolated for a particular item. When this method exits, all properties in this Object should have non-NaN values.
	srcCache:Array — The Array of source chart items that are being interpolated.
	destProps:Object — An Object containing the destination values that are being interpolated for a particular item. When this method exits, all properties in this Object should have non-NaN values.
	destCache:Array — The Array of destination chart items that are being interpolated.
	index:Number — The index of the item that is being populated in the cache.
	customData:Object — The data that was passed by the series into the initializeInterpolationData() method.

public function getRenderDataForTransition(type:String):Object

Returns a copy of the data needed to represent this series's data. This method is called by SeriesEffects to capture the before and after state of the series for animation.

If you implement a custom series type, you generally do not override this method. Instead, you should override the renderData() accessor.

Parâmetros

type:String — Indicates whether the effect is requesting a description of the data being hidden, or the new data being shown.

Retorna

Object

protected function initializeInterpolationData(srcCache:Array, dstCache:Array, iProps:Object, cacheType:Classe = null, customData:Object = null):Object

Helper function for Series to implement the interpolation effect. A custom series can call this function from its beginInterpolation() method to initialize a data structure to interpolate an arbitrary set of numeric properties over the life of the effect. You can pass that data structure to the applyInterpolation() utility method to actually modify the values when your interpolate() method is called.

Parâmetros

	srcCache:Array — An array of objects whose fields contain the beginning values for the interpolation.
	dstCache:Array — An array of objects whose fields contain the ending values for the interpolation.
	iProps:Object — A hashtable whose keys identify the names of the properties from the cache to be interpolated.
	cacheType:Classe (default = null) — The class to instantiate that holds the delta values computed for the interpolation. Typically this is null, in which case a generic Object is used.
	customData:Object (default = null) — An object containing series-specific data. When the initialization process encounters a missing value, it calls the series's getMissingInterpolationValues() method to fill in the missing value. This custom data is passed to that method, and can be used to pass through arbitrary parameters.

Retorna

Object

public function interpolate(interpolationValues:Array, interpolationData:Object):void

Called by the SeriesInterpolate effect to advance an interpolation. The effect calls this once per frame until the interpolation is complete. The series is responsible for using the parameters to render the interpolated values. By default, the series assumes that interpolationData is a data structure returned by the initializeInterpolationData() method, and passes it through to the applyInterpolation() method.

Parâmetros

	interpolationValues:Array — An Array of Numbers, each ranging from 0 to 1, where the nth number indicates the percentage of the way the nth value in the data series should be interpolated between the start and end values.
	interpolationData:Object — The data returned from the beginInterpolation() method.

protected function invalidateData(invalid:Boolean = true):void

Informs the series that the underlying data in the dataProvider has changed. This function triggers calls to the updateData(), updateMapping(), updateFilter(), and updateTransform() methods on the next call to the commitProperties() method. If any data effects are assigned to any elements of the chart, this method also triggers the show and hide effects.

Parâmetros

invalid:Boolean (default = true)

protected function invalidateFilter(invalid:Boolean = true):void

Informs the series that the filter of the data against the axes has changed and must be recalculated. Calling this method triggers calls to the updateFilter() and updateTransform() methods on the next call to the commitProperties() method. If any data effects are assigned to any elements of the chart, this method also triggers the show and hide effects.

Parâmetros

invalid:Boolean (default = true)

protected function invalidateMapping(invalid:Boolean = true):void

Informs the series that the mapping of the data into numeric values has changed and must be recalculated. Calling this function triggers calls to the updateMapping(), updateFilter(), and updateTransform() methods on the next call to the commitProperties() method. If any data effects are assigned to any elements of the chart, this method also triggers the show and hide effects.

Parâmetros

invalid:Boolean (default = true)

protected function invalidateTransform(invalid:Boolean = true):void

Informs the series that the transform the data to screen coordinates has changed and must be recalculated. Calling this function triggers a call to the updateTransform() method on the next call to the commitProperties() method.

Parâmetros

invalid:Boolean (default = true)

protected function invalidateTransitions():void

Informs the series that a significant change has occured in the display of data. This triggers any showData and hideData effects.

protected function legendDataChanged():void

Updates the Legend items when the series display name changes by dispatching a new LegendDataChanged event.

public override function setActualSize(w:Number, h:Number):void

Sizes the object. Unlike directly setting the width and height properties, calling the setActualSize() method does not set the explictWidth and explicitHeight properties, so a future layout calculation may result in the object returning to its previous size. This method is used primarily by component developers implementing the updateDisplayList() method, by Effects, and by the LayoutManager.

Parâmetros

	w:Number — Width of the object.
	h:Number — Height of the object.

public function setAxis(dimension:String, value:IAxis):void

Assigns an axis instance to a particular dimension of the chart. This is a low level accessor. You typically set the Axis directly through a named property (such as for a cartesian based series horizontalAxis, verticalAxis, or radiusAxis).

Parâmetros

	dimension:String
	value:IAxis

protected function stripNaNs(cache:Array, field:String):void

Removes any item from the provided cache whose field property is NaN. Derived classes can call this method from their updateFilter() implementation to remove any ChartItems filtered out by the axes.

Parâmetros

	cache:Array
	field:String

public override function stylesInitialized():void

Calls the legendDataChanged() method.

protected function updateData():void

This method is called when the underlying data that the series represents has changed and needs to be reloaded out of the data provider. If you implement custom series types, you should override this method and load all data necessary to render the series out of the backing data provider. You must also be sure to call the super.updateData() method in your subclass. You do not generally call this method directly. Instead, to guarantee that your data has been updated at a given point, call the validateData() method of the Series class.

protected override function updateDisplayList(unscaledWidth:Number, unscaledHeight:Number):void

Draws the object and/or sizes and positions its children. This is an advanced method that you might override when creating a subclass of UIComponent.

You do not call this method directly. Flex calls the updateDisplayList() method when the component is added to a container using the addChild() method, and when the component's invalidateDisplayList() method is called.

If the component has no children, this method is where you would do programmatic drawing using methods on the component's Graphics object such as graphics.drawRect().

If the component has children, this method is where you would call the move() and setActualSize() methods on its children.

Components may do programmatic drawing even if they have children. In doing either, you should use the component's unscaledWidth and unscaledHeight as its bounds.

It is important to use unscaledWidth and unscaledHeight instead of the width and height properties.

Parâmetros

	unscaledWidth:Number — Specifies the width of the component, in pixels, in the component's coordinates, regardless of the value of the scaleX property of the component.
	unscaledHeight:Number — Specifies the height of the component, in pixels, in the component's coordinates, regardless of the value of the scaleY property of the component.

protected function updateFilter():void

This method is called when the underlying data the series represents needs to be filtered against the ranges represented by the axes of the associated DataTransform. This can happen either because the underlying data has changed, or because the range of the associated axes have changed. If you implement a custom series type, you should override this method and filter out any outlying data using the filterCache() method of the axes managed by its associated DataTransform. The filterCache() method converts any values out of range to NaN. You must be sure to call the super.updateFilter() method in your subclass. You should not generally call this method directly. Instead, if you need to guarantee that your data has been filtered at a given point, call the validateTransform() method of the Series class. You can generally assume that your updateData() and updateMapping() methods have been called prior to this method, if necessary.

protected function updateMapping():void

This method is called when the underlying data the series represents needs to be mapped to numeric representations. This can happen either because the underlying data has changed, or because the axes used to render the series have changed in some relevant way. If you implement a custom series, you should override this method and convert the data represented into numeric values using the mapCache() method of the axes managed by its associated DataTransform. You must also be sure to call the super.updateMapping() method in your subclass. You should not generally call this method directly. Instead, to guarantee that your data has been mapped at a given point, call the validateData() method of the Series class. You can generally assume that your updateData() method has been called prior to this method, if necessary.

protected function updateTransform():void

This method is called when the underlying data the series represents needs to be transformed from data to screen values by the axes of the associated DataTransform. This can happen either because the underlying data has changed, because the range of the associated axes have changed, or because the size of the area on screen has changed. If you implement a custom series type, you should override this method and transform the data using the transformCache() method of the associated DataTransform. You must be sure to call the super.updateTransform() method in your subclass. You should not generally call this method directly. Instead, if you need to guarantee that your data has been filtered at a given point, call the valiateTransform() method of the Series class. You can generally assume that your updateData(), updateMapping(), and updateFilter() methods have been called prior to this method, if necessary.

protected function validateData():void

Calls the series's updateData() and updateMapping() functions, if necessary. This function is called automatically by the series during commitProperties, as necessary, but a derived series might call it explicitly if the generated values are needed at an explicit time. Loading and mapping of data against the axes is defined to be acceptable at any point by the axes; this function is safe to call explicitly at any point.

protected function validateTransform():void

Calls the series's updateFilter() and updateTransform() functions, if necessary. This function is called automatically by the series during commitProperties(), as necessary, but a derived series might call it explicitly, if the generated values are needed at an explicit time. Filtering and transforming of data relies on specific values calculated by the axes, which can, in turn, depend on the data displayed in the chart. Calling this function at the wrong time might result in extra work being done if those values are updated.