AxisRenderer  - AS3 Flex

The axis object associated with this renderer. This property is managed by the enclosing chart, and could be explicitly set if multiple axes renderers are used.

The base chart for this AxisRenderer.

The distance between the axisRenderer and the sides of the surrounding chart. This property is assigned automatically by the chart, and should not be assigned directly.

The maximum amount of space, in pixels, that an axis renderer will take from a chart. Axis Renderers by default will take up as much space in the chart as necessary to render all of their labels at full size. If heightLimit is set, an AxisRenderer will resort to reducing the labels in size in order to guarantee the total size of the axis is less than heightLimit.

Specifies wheter to highlight chart elements like Series on mouse rollover.

true if the axis renderer is being used as a horizontal axis. This property is managed by the enclosing CartesianChart, and should not be set directly.

Called to format axis renderer values for display as labels. A labelFunction has the following signature:

      function labelFunction(axisRenderer:IAxisRenderer, label:String):String { ... }
      

A reference to the factory used to render the axis labels. This type must implement the IDataRenderer and IFlexDisplayObject interfaces.

The AxisRenderer will create one instance of this class for each label on the axis. The labelRenderer's data property is assigned an AxisLabel object containing the value and label to be rendered.

Specifies the length of the axis, in screen coordinates. The default length depends on a number of factors, including the size of the chart, the size of the labels, how the AxisRenderer chooses to lay out labels, and any requirements imposed by other portions of the chart.

Contains an array that specifies where Flex draws the minor tick marks along the axis. Each array element contains a value between 0 and 1.

A module factory is used as context for using embedded fonts and for finding the style manager that controls the styles for this component.

An Array of axes.

The side of the chart the axisRenderer will appear on. Legal values are "left" and "right" for vertical axis renderers and "top" and "bottom" for horizontal axis renderers. By default, primary axes are placed on the left and top, and secondary axes are placed on the right and bottom. CartesianCharts automatically guarantee that secondary axes are placed opposite primary axes; if you explicitly place a primary vertical axis on the right, for example, the secondary vertical axis is swapped to the left.

Contains an array that specifies where Flex draws the tick marks along the axis. Each array element contains a value between 0 and 1.

A reference to the factory used to render the axis title. This type must extend UIComponent and implement the IDataRenderer and IFlexDisplayObject interfaces.

The AxisRenderer will create an instance of this class for title of the axis. The titleRenderer's data property is assigned the title to be rendered.

Constructor.

Adjusts its layout to accomodate the gutters passed in. This method is called by the enclosing chart to determine the size of the gutters and the corresponding data area. This method provides the AxisRenderer with an opportunity to calculate layout based on the new gutters, and to adjust them if necessary. If a given gutter is adjustable, an axis renderer can optionally adjust the gutters inward (make the gutter larger) but not outward (make the gutter smaller).

Parameters

Called by the chart to indicate when its current transition state has changed.

Parameters

Marks a component so that its updateDisplayList() method gets called during a later screen update.

Invalidation is a useful mechanism for eliminating duplicate work by delaying processing of changes to a component until a later screen update. For example, if you want to change the width and height, it would be wasteful to update the component immediately after you change the width and then update again with the new height. It is more efficient to change both properties and then render the component with its new size once.

Invalidation methods rarely get called. In general, setting a property on a component automatically calls the appropriate invalidation method.

Marks a component so that its measure() method gets called during a later screen update.

Invalidation is a useful mechanism for eliminating duplicate work by delaying processing of changes to a component until a later screen update. For example, if you want to change the text and font size, it would be wasteful to update the text immediately after you change it and then update the size when it gets set. It is more efficient to change both properties and then render the text with its new size once.

Invalidation methods rarely get called. In general, setting a property on a component automatically calls the appropriate invalidation method.

Calculates the default size, and optionally the default minimum size, of 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 measure() method when the component is added to a container using the addChild() method, and when the component's invalidateSize() method is called.

When you set a specific height and width of a component, Flex does not call the measure() method, even if you explicitly call the invalidateSize() method. That is, Flex only calls the measure() method if the explicitWidth property or the explicitHeight property of the component is NaN.

In your override of this method, you must set the measuredWidth and measuredHeight properties to define the default size. You can optionally set the measuredMinWidth and measuredMinHeight properties to define the default minimum size.

Most components calculate these values based on the content they are displaying, and from the properties that affect content display. A few components simply have hard-coded default values.

The conceptual point of measure() is for the component to provide its own natural or intrinsic size as a default. Therefore, the measuredWidth and measuredHeight properties should be determined by factors such as:

• The amount of text the component needs to display.
• The styles, such as fontSize, for that text.
• The size of a JPEG image that the component displays.
• The measured or explicit sizes of the component's children.
• Any borders, margins, and gaps.

In some cases, there is no intrinsic way to determine default values. For example, a simple GreenCircle component might simply set measuredWidth = 100 and measuredHeight = 100 in its measure() method to provide a reasonable default size. In other cases, such as a TextArea, an appropriate computation (such as finding the right width and height that would just display all the text and have the aspect ratio of a Golden Rectangle) might be too time-consuming to be worthwhile.

The default implementation of measure() sets measuredWidth, measuredHeight, measuredMinWidth, and measuredMinHeight to 0.

Moves this object to the specified x and y coordinates.

Parameters

Sets the actual size of this object.

This method is mainly for use in implementing the updateDisplayList() method, which is where you compute this object's actual size based on its explicit size, parent-relative (percent) size, and measured size. You then apply this actual size to the object by calling setActualSize().

In other situations, you should be setting properties such as width, height, percentWidth, or percentHeight rather than calling this method.

Parameters

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 can do programmatic drawing even if they have children. In doing either, 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