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

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

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. 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.

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 createChildren():void

public override 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.

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 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.

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 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 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 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 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.