angularAxis:IAxis  [read-write]

The axis object used to map data values to an angle between 0 and 2 PI. By default, this is a linear axis with the autoAdjust property set to false. So, data values are mapped uniformly around the chart.

Implementation
    public function get angularAxis():IAxis
    public function set angularAxis(value:IAxis):void

explodeRadius:Number  [read-write]

A number from 0 to 1, specifying how far all wedges of the pie series should be exploded from the center of the chart as a percentage of the total radius.

This value explodes all wedges in the pie series uniformly. You can set the value for individual wedges via the perWedgeExplodeRadius property.

The explode radius for any individual wedge is the value of the explodeRadius property plus its value in the perWedgeExplodeRadius Array.

To guarantee that the pie series stays within its containing chart's bounds while pulling out wedges, the pie series might shrink the total radius of the pie. If you dynamically pull out wedges at run time, the total pie radius shrinks. To avoid this effect, you can "reserve" the space and shrink the total radius initially by setting the reserveExplodeRadius property to the maximum explode radius you intend to set at run time.

Implementation
    public function get explodeRadius():Number
    public function set explodeRadius(value:Number):void

field:String  [read-write]

Specifies the field of the data provider that determines the data for each wedge of the PieChart control.

The default value is null.

Implementation
    public function get field():String
    public function set field(value:String):void

fillFunction:Function  [read-write]

Specifies a method that returns the fill for the current chart item in the series. If this property is set, the return value of the custom fill function takes precedence over the fills style property. But if it returns null, then fills will be prefered.

The custom fillFunction has the following signature:

     function_name (item:ChartItem, index:Number):IFill { ... }
     

item is a reference to the chart item that is being rendered. index is the index of the item in the series's data provider. This function returns an object that implements the IFill interface.

An example usage of a customized fillFunction is to return a fill based on some threshold.

Implementation
    public function get fillFunction():Function
    public function set fillFunction(value:Function):void

Example
How to use examples

     public function myFillFunction(item:ChartItem, index:Number):IFill {
          var curItem:PieSeriesItem = PieSeriesItem(item);
          if(curItem.number > 10)
              return(new SolidColor(0x123456, .75));
          else
              return(new SolidColor(0x563412, .75));
     }
     

If you specify a custom fill function for your chart series and you want to have a Legend control, you must manually create a Legend control and add LegendItems to it.

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.

Implementation
    public function get items():Array

itemType:Class  [read-only]

The subtype of ChartItem used by this series to represent individual items. Subclasses can override and return a more specialized class if they need to store additional information in the items.

Implementation
    protected function get itemType():Class

labelField:String  [read-write]

Name of a field in the data provider whose value appears as label Ignored if labelFunction is specified

Implementation
    public function get labelField():String
    public function set labelField(value:String):void

labelFunction:Function  [read-write]

Specifies a callback function used to render each label of the PieSeries. The callback function has the following format:

      function_name(data:Object, field:String, index:Number, percentValue:Number):String { ... }
      

The data Object is the dataProvider item being rendered. The field String is the name of the field in the data that is being rendered. The index Number is the index in the original dataProvider of the item being rendered. The percent Number is the percentage of the total this item represents. This function returns a String that is the label for this item.

Implementation
    public function get labelFunction():Function
    public function set labelFunction(value:Function):void

public var maxLabelRadius:Number = 0.6

The maximum amount of the PieSeries's radius that can be allocated to labels. This value is only applicable when the series is rendering callout labels.

When rendering callout labels, the PieSeries reduces the radius of the wedges to allow space for the labels along the sides. Once the amount of space allocated to the labels reaches this limit, the series begins reducing the size of the labels to stay within this size.

nameField:String  [read-write]

Specifies the field of the data provider that determines the name of each wedge of the PieChart control.

The default value is null.

Implementation
    public function get nameField():String
    public function set nameField(value:String):void

outerRadius:Number  [read-write]

The percentage of the total space available to the PieSeries to use when rendering the contents of the series. This value is managed by the containing chart, and should not be assigned to directly.

This value ranges from 0 to 1.

Implementation
    public function get outerRadius():Number
    public function set outerRadius(value:Number):void

perWedgeExplodeRadius:Array  [read-write]

An Array of numbers from 0 to 1, specifying how far each wedge of the pie series should be exploded from the center of the chart as a percentage of the total radius.

The nth value in this Array corresponds to the nth pie wedge. For example, to pull the third wedge half way out, you assign perWedgeExplodeRadius = [ 0, 0, 50];.

null or missing values in the Array are treated as 0.

To guarantee that the pie series stays within its containing chart's bounds while pulling out wedges, the pie series might shrink the total radius of the pie.

If you dynamically pull out wedges at run time, the total pie radius shrinks. To avoid this effect, you can "reserve" the space and shrink the total radius initially by setting the reserveExplodeRadius property to the maximum explode radius you intend to set at run time.

The value for an individual wedge in the perWedgeExplodeRadius Array is added to the value of the series's explodeRadius property to calculate the total explode radius for any given wedge.

Implementation
    public function get perWedgeExplodeRadius():Array
    public function set perWedgeExplodeRadius(value:Array):void

renderDataType:Class  [read-only]

The subtype of ChartRenderData used by this series to store all data necessary to render. Subclasses can override and return a more specialized class if they need to store additional information for rendering.

Implementation
    protected function get renderDataType():Class

reserveExplodeRadius:Number  [read-write]

A number from 0 to 1, specifying how much of the total radius of the pie series should be reserved to explode wedges at runtime. When a pie wedge is exploded, the series must shrink the total radius of the pie to make sure it doesn't exceed the bounds of its containing chart. Thus if a developer changes the explode value of a wedge at runtime, it can effectively shrink all the wedges rather than the desired effect of pulling out a single wedge. To avoid this, set reserveExplodeRadius to the maximum value you intend to explode any wedge at runtime.

Implementation
    public function get reserveExplodeRadius():Number
    public function set reserveExplodeRadius(value:Number):void

startAngle:Number  [read-write]

Specifies the starting angle for the first slice of the PieChart control. The default value is 0, which is horizontal on the right side of the PieChart control.

Implementation
    public function get startAngle():Number
    public function set startAngle(value:Number):void

public function PieSeries()

Constructor.

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

Called by the SeriesInterpolate effect to initiate an interpolation effect. 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 interpolate() method of the series to advance the animation for the duration of the effect. The series calculates the data it needs to perform the interpolation and returns it in this method.

Parameters

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

Returns

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

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.

protected override function createChildren():void

Create child objects of the component. This is an advanced method that you might override when creating a subclass of UIComponent.

A component that creates other components or objects within it is called a composite component. For example, the Flex ComboBox control is actually made up of a TextInput control to define the text area of the ComboBox, and a Button control to define the ComboBox arrow. Components implement the createChildren() method to create child objects (such as other components) within the component.

From within an override of the createChildren() method, you call the addChild() method to add each child object.

You do not call this method directly. Flex calls the createChildren() method in response to the call to the addChild() method to add the component to its parent.

public override function dataToLocal(... dataValues):Point

Converts a tuple of data values to an x-y coordinate on screen. Call this function to transform data on to the screen using the same transform that the individual elements go through. For example, to create a custom highlight for a data region of a chart, you might use this function to determine the on-screen coordinates of the range of interest.

For Cartesian chartelements, you typically pass two values. The first value maps to the horizontal axis, and the second value maps to the vertical axis.

For polar charts, the first value maps to the angular axis, and the second maps to the radial axis.

Parameters

... dataValues — The data values to convert to coordinates.

Returns

Point — Coordinates that are relative to the chart.

public override function getElementBounds(renderData:Object):void

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

Parameters

renderData:Object

protected override 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 Arrays of source and destination values for the interpolation. If either of those two Arrays is incomplete, the series must 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.

Parameters

	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 values other than NaN.
	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 values other than NaN.
	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 override 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.

Parameters

	interpolationValues:Array — An Array of Numbers, each ranging from 0 to 1, where the nth number indicates the percentage of the way in which 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.

public override function localToData(pt:Point):Array

Converts a coordinate on screen to a tuple of data values. Call this function to determine what data values a particular point on-screen represents.

Individual chart types determine how this transformation occurs. The point should be relative to the chart's coordinate space.

Parameters

pt:Point — The Point to convert.

Returns

Array — The tuple of data values.

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.

Parameters

	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.