Documentation for classes includes syntax, usage information, and code samples for methods, properties, and event handlers and listeners for those APIs that belong to a specific class in ActionScript. The classes are listed alphabetically. If you are not sure to which class a certain method or property belongs, you can look it up in the Index.


 ClassPackageDescription
 AccConst
mx.accessibility The AccConst class defines constants defined in Microsoft's Active Accessibility (MSAA) specification.
 AccImpl
mx.accessibility AccImpl is Flex's base accessibility implementation class for MX and Spark components.
 AddRemoveEffectTargetFilter
mx.effects.effectClasses AddRemoveEffectTargetFilter is a subclass of EffectTargetFilter that handles the logic for filtering targets that have been added or removed as children to a container.
 Animation
spark.effects.animation The Animation class defines an animation that happens between the start and end values of a property over a specified period of time.
 ArrayList
mx.collections The ArrayList class is a simple implementation of IList that uses a backing Array as the source of the data.
 ArrayUtil
mx.utils The ArrayUtil utility class is an all-static class with methods for working with arrays within Flex.
 AutoCompleteComboBoxLite
spark.flextras.autoCompleteComboBox The Flextras AutoCompleteComboBoxLite is a native Spark Flex component built to provide AutoComplete functionality in your Flex Applications> AutoComplete is sometimes called AutoSuggest.
 BaseFilter
mx.filters 
 BaseListData
mx.controls.listClasses The BaseListData class defines the data type of the listData property implemented by drop-in item renderers or drop-in item editors.
 BasicLayout
spark.layouts The BasicLayout class arranges the layout elements according to their individual settings, independent of each-other.
 Button
mx.controls The Button control is a commonly used rectangular button.
 Button
spark.components The Button component is a commonly used rectangular button.
 ButtonAccImpl
mx.accessibility ButtonAccImpl is a subclass of AccessibilityImplementation which implements accessibility for the Button class.
 ButtonBase
spark.components.supportClasses The ButtonBase class is the base class for the all Spark button components.
 ButtonBaseAccImpl
spark.accessibility ButtonBaseAccImpl is the accessibility implementation class for spark.components.supportClasses.ButtonBase.
 ButtonLabelPlacement
mx.controls The ButtonLabelPlacement class defines the constants for the allowed values of the labelPlacement property of a Button, CheckBox, LinkButton, or RadioButton control.
 ChildExistenceChangedEvent
mx.events Represents events that are dispatched when a the child of a control is created or destroyed.
 ClassFactory
mx.core A ClassFactory instance is a "factory object" which Flex uses to generate instances of another class, each with identical properties.
 CollectionEvent
mx.events The mx.events.CollectionEvent class represents an event that is dispatched when the associated collection changes.
 CollectionEventKind
mx.events The CollectionEventKind class contains constants for the valid values of the mx.events.CollectionEvent class kind property.
 CollectionViewError
mx.collections.errors The CollectionViewError class represents general errors within a collection that are not related to specific activities such as Cursor seeking.
 ColorBurnShader
mx.graphics.shaderClasses Creates a blend shader that is equivalent to the 'Color Burn' blend mode for RGB premultiplied colors available in Adobe Creative Suite tools.
 ColorDodgeShader
mx.graphics.shaderClasses Creates a blend shader that is equivalent to the 'Color Dodge' blend mode for RGB premultiplied colors available in Adobe Creative Suite tools.
 ColorShader
mx.graphics.shaderClasses The ColorShader class creates a blend shader that is equivalent to the 'Color' blend mode for RGB premultiplied colors available in Adobe Creative Suite tools.
 ColorUtil
mx.utils The ColorUtil class is an all-static class with methods for working with RGB colors within Flex.
 ComboBox
spark.components The ComboBox control is a child class of the DropDownListBase control.
 ComboBoxAccImpl
spark.accessibility ComboBoxAccImpl is the accessibility implementation class for spark.components.ComboBox.
 ComponentDescriptor
mx.core ComponentDescriptor is the base class for the UIComponentDescriptor class, which encapsulates the information that you specified in an MXML tag for an instance of a visual component.
 CompoundTransform
mx.geom A CompoundTransform represents a 2D or 3D matrix transform.
 Container
mx.core The Container class is an abstract base class for components that controls the layout characteristics of child components.
 ContainerCreationPolicy
mx.core The ContainerCreationPolicy class defines the constant values for the creationPolicy property of the Container class.
 CSSCondition
mx.styles Represents a condition for a CSSSelector which is used to match a subset of components based on a particular property.
 CSSConditionKind
mx.styles An enumeration of the kinds of CSSCondition.
 CSSSelector
mx.styles Represents a selector node in a potential chain of selectors used to match CSS style declarations to components.
 CSSStyleDeclaration
mx.styles The CSSStyleDeclaration class represents a set of CSS style rules.
 CursorBookmark
mx.collections Encapsulates the positional aspects of a cursor in an ICollectionView.
 CursorError
mx.collections.errors This error is thrown by a collection Cursor.
 CursorManager
mx.managers The CursorManager class controls a prioritized list of cursors, where the cursor with the highest priority is currently visible.
 CursorManagerPriority
mx.managers The CursorManagerPriority class defines the constant values for the priority argument to the CursorManager.setCursor() method.
 DataGridListData
mx.controls.dataGridClasses The DataGridListData class defines the data type of the listData property that is implemented by drop-in item renderers or drop-in item editors for the DataGrid control.
 DataGroup
spark.components The DataGroup class is the base container class for data items.
 DataRenderer
spark.components The DataRenderer class is the base class for data components in Spark.
 DefaultItemRenderer
spark.skins.spark The DefaultItemRenderer class defines the default item renderer for a List control.
 DesignLayer
mx.core The DesignLayer class represents a visibility group that can be associated with one or more IVisualElement instances at runtime.
 DisplayLayer
spark.components.supportClasses A DisplayLayer class maintains an ordered list of DisplayObjects sorted on depth.
 DisplayObjectSharingMode
spark.core The DisplayObjectSharingMode class defines the possible values for the displayObjectSharingMode property of the IGraphicElement class.
 DragEvent
mx.events The DragEvent class represents event objects that are dispatched as part of a drag-and-drop operation.
 DragManager
mx.managers The DragManager class manages drag and drop operations, which let you move data from one place to another in a Flex application.
 DragSource
mx.core The DragSource class contains the data being dragged.
 DropDownController
spark.components.supportClasses The DropDownController class handles the mouse, keyboard, and focus interactions for an anchor button and its associated drop down.
 DropDownEvent
spark.events The DropDownEvent class represents the event object passed to the event listener for the open and close events.
 DropDownListBase
spark.components.supportClasses The DropDownListBase control contains a drop-down list from which the user can select a single value.
 DropDownListBaseAccImpl
spark.accessibility DropDownListAccImpl is the accessibility implementation class for spark.components.supportClasses.DropDownListBase.
 DropLocation
spark.layouts.supportClasses The DropLocation class contains information describing the drop location for the dragged data in a drag-and-drop operation.
 DynamicEvent
mx.events This subclass of Event is dynamic, meaning that you can set arbitrary event properties on its instances at runtime.
 EaseInOutBase
spark.effects.easing The EaseInOutBase class is the base class that provide easing capability.
 EasingFraction
spark.effects.easing The EasingFraction class defines constants for the easeInFraction property of the EaseInOutBase class.
 EdgeMetrics
mx.core The EdgeMetrics class specifies the thickness, in pixels, of the four edge regions around a visual component.
 Effect
mx.effects The Effect class is an abstract base class that defines the basic functionality of all Flex effects.
 EffectEvent
mx.events Represents event objects that are specific to Flex effects.
 EffectInstance
mx.effects The EffectInstance class represents an instance of an effect playing on a target.
 EffectManager
mx.effects The EffectManager class listens for events, such as the show and move events, dispatched by objects in a Flex application.
 EffectTargetFilter
mx.effects The EffectTargetFilter class defines a custom filter that is executed by each transition effect on each target of the effect.
 ElementExistenceEvent
spark.events The ElementExistenceEvent class represents events that are dispatched when an element of a Group is created or destroyed.
 EventPriority
mx.core The EventPriority class defines constant values for the priority argument of the addEventListener() method of EventDispatcher.
 ExclusionShader
mx.graphics.shaderClasses Creates a blend shader that is equivalent to the 'Exclusion' blend mode for RGB premultiplied colors available in Adobe Creative Suite tools.
 FlexEvent
mx.events The FlexEvent class represents the event object passed to the event listener for many Flex events.
 FlexGlobals
mx.core A class that contains variables that are global to all applications within the same ApplicationDomain.
 FlexMouseEvent
mx.events The FlexMouseEvent class represents the event object passed to the event listener for Flex-specific mouse activity.
 FlexShape
mx.core FlexShape is a subclass of the Player's Shape class.
 FlexSprite
mx.core FlexSprite is a subclass of the Player's Sprite class and the superclass of UIComponent.
 FlexTextField
mx.core FlexTextField is a subclass of the Player's TextField class and the superclass of UITextField.
 FlexVersion
mx.core This class controls the backward-compatibility of the framework.
 GraphicsUtil
mx.utils The Graphics class is an all-static class with utility methods related to the Graphics class.
 Group
spark.components The Group class is the base container class for visual elements.
 GroupBase
spark.components.supportClasses The GroupBase class defines the base class for components that display visual elements.
 HideShowEffectTargetFilter
mx.effects.effectClasses HideShowEffectTargetFilter is a subclass of EffectTargetFilter that handles the logic for filtering targets that have been shown or hidden by modifying their visible property.
 HScrollBar
mx.controls The HScrollBar (horizontal ScrollBar) control lets you control the portion of data that is displayed when there is too much data to fit in a display area.
 HScrollBar
spark.components The HScrollBar (horizontal scrollbar) control lets you control the portion of data that is displayed when there is too much data to fit horizontally in a display area.
 HueShader
mx.graphics.shaderClasses Creates a blend shader that is equivalent to the 'Hue' blend mode for RGB premultiplied colors available in Adobe Creative Suite tools.
 IAbstractEffect
mx.effects The IAbstractEffect interface is used to denote that a property or parameter must be of type Effect, but does not actually implement any of the APIs of the IEffect interface.
 IAdvancedStyleClient
mx.styles This interface describes the advanced properties that a component must implement to fully participate in the advanced style subsystem.
 IAnimationTarget
spark.effects.animation The IAnimationTarget interface is implemented by classes that support the events for an Animation instance.
 IAutoCompleteRenderer
spark.flextras.autoCompleteComboBox.renderers This is an interface that defines the itemRenderer used in the Flextras Spark AutoCompleteComboBox.
 IAutomationObject
mx.automation The IAutomationObject interface defines the interface for a delegate object that implements automation for a component.
 IBindingClient
mx.binding This is used to mark documents, which have data bindings.
 IBitmapFilter
mx.filters Interface used by some Spark filters.
 IBorder
mx.core The IBorder interface defines the interface that all classes used for border skins should implement.
 IButton
mx.core The IButton interface is a marker interface that indicates that a component acts as a button.
 IChildList
mx.core The IChildList interface defines the properties and methods for accessing and manipulating child lists, which are subsets of a DisplayObjectContainer's children.
 ICollectionView
mx.collections An ICollectionView is a view onto a collection of data.
 IConstraintClient
mx.core The IConstraintClient interface defines the interface for components that support layout constraints.
 IContainer
mx.core IContainer is a interface that indicates a component extends or mimics mx.core.Container
 IDataRenderer
mx.core The IDataRenderer interface defines the interface for components that have a data property.
 IDeferredContentOwner
mx.core The IDeferredContentOwner interface defines the properties and methods for deferred instantiation.
 IDeferredInstantiationUIComponent
mx.core The IDeferredInstantiationUIComponent interface defines the interface for a component or object that defers instantiation.
 IDropInListItemRenderer
mx.controls.listClasses The interface for "drop-in" item renderers.
 IEaser
spark.effects.easing The IEaser interface is implemented by classes that provide time-easing functionality for the Animation class.
 IEffect
mx.effects The IEffect interface defines the base interface of all Flex effects.
 IEffectInstance
mx.effects The IEffectInstance interface represents an instance of an effect playing on a target.
 IEffectTargetHost
mx.effects The IEffectTargetHost interface defines the interface that lets you access the target list-based control of a data effect.
 IFactory
mx.core The IFactory interface defines the interface that factory classes such as ClassFactory must implement.
 IFlexAsset
mx.core IFlexAsset is a marker interface with the following meaning: if a class declares that it implements IFlexAsset, then that class represents an asset -- such as a bitmap, a font, or a sound -- that has been embedded in a Flex application.
 IFlexContextMenu
mx.controls The IFlexContextMenu interface defines the interface for a Flex context menus.
 IFlexDisplayObject
mx.core The IFlexDisplayObject interface defines the interface for skin elements.
 IFlexModule
mx.core The IFlexModule interface is used as an optional contract with IFlexModuleFactory.
 IFlexModuleFactory
mx.core The IFlexModuleFactory interface represents the contract expected for bootstrapping Flex applications and dynamically loaded modules.
 IFocusManager
mx.managers The IFocusManager interface defines the interface that components must implement to manage the focus on components in response to mouse activity or keyboard activity (Tab key), and to support a default button.
 IFocusManagerComponent
mx.managers The IFocusManagerComponent interface defines the interface that focusable components must implement in order to receive focus from the FocusManager.
 IFocusManagerContainer
mx.managers The IFocusManagerContainer interface defines the interface that containers implement to host a FocusManager.
 IFontContextComponent
mx.core Allows a component to support a font context property.
 IGraphicElement
spark.core The IGraphicElement is implemented by IVisualElements that take advantage of the parent Group's DisplayObject management.
 IIMESupport
mx.core The IIMESupport interface defines the interface for any component that supports IME (input method editor).
 IInterpolator
spark.effects.interpolation The IInterpolator interface is implemented by classes that calculate values for the Animation class.
 IInvalidating
mx.core The IInvalidating interface defines the interface for components that use invalidation to do delayed -- rather than immediate -- property commitment, measurement, drawing, and layout.
 IItemRenderer
spark.components The IItemRenderer interface defines the basic set of APIs that a class must implement to create an item renderer that can communicate with a host component.
 IItemRendererOwner
spark.components The IItemRendererOwner interface defines the basic set of APIs that a class must implement to support items renderers.
 ILayoutElement
mx.core The ILayoutElement interface is used primarily by the layout classes to query, size and position the elements of GroupBase containers.
 ILayoutManager
mx.managers The LayoutManager is the engine behind Flex's measurement and layout strategy.
 ILayoutManagerClient
mx.managers The ILayoutManagerClient interface defines the interface that a component must implement to participate in the LayoutManager's commit/measurement/layout sequence.
 IList
mx.collections A collection of items organized in an ordinal fashion.
 IListItemRenderer
mx.controls.listClasses Item renderers and item editors for list components must implement the IListItemRenderer interface.
 IModule
mx.modules An interface that marks a class as being a module.
 IModuleInfo
mx.modules An interface that acts as a handle for a particular module.
 IMXMLObject
mx.core The IMXMLObject interface defines the APIs that a non-visual component must implement in order to work properly with the MXML compiler.
 INavigatorContent
mx.core The INavigatorContent interface defines the interface that a container must implement to be used as the child of a navigator container, such as the ViewStack, TabNavigator, and Accordion navigator containers.
 IndexChangedEvent
mx.events The IndexChangedEvent class represents events that are dispatched when an index changes.
 IndexChangeEvent
spark.events The IndexChangeEvent class represents events that are dispatched when an index changes in a Spark component.
 InterDragManagerEvent
mx.events An event sent between DragManagers that are in separate but trusted ApplicationDomains to handle the dispatching of DragEvents to the drag targets.
 InterManagerRequest
mx.events This is an event that is sent between ApplicationDomains to notify trusted listeners about activity in a particular manager.
 IOverride
mx.states The IOverride interface is used for view state overrides.
 IPreloaderDisplay
mx.preloaders Defines the interface that a class must implement to be used as a download progress bar.
 IProgrammaticSkin
mx.core The IProgrammaticSkin interface defines the interface that skin classes must implement if they use the name property skin interface.
 IPropertyChangeNotifier
mx.core The IPropertyChangeNotifier interface defines a marker interface.
 IRawChildrenContainer
mx.core The IRawChildrenContainer interface defines the APIs for containers that can return an IChildList that represents all their children.
 IRectangularBorder
mx.core The IRectangularBorder interface defines the interface that all classes used for rectangular border skins should implement.
 IRepeater
mx.core The IRepeater interface defines the public APIs of the Repeater object.
 IRepeaterClient
mx.core The IRepeaterClient interface defines the APIs for components that can have multiple instances created by a Repeater.
 IResourceBundle
mx.resources The IResourceBundle and IResourceManager interfaces work together to provide localization support for Flex applications.
 IResourceManager
mx.resources The APIs of the IResourceManager interface provide localization support for Flex applications.
 IResponder
mx.rpc This interface provides the contract for any service that needs to respond to remote or asynchronous calls.
 ISharedDisplayObject
spark.core The ISharedDisplayObject interface defines the minimum requirements that a DisplayObject must implement to be shared between IGraphicElement objects.
 ISimpleStyleClient
mx.styles This interface describes the properties and methods that an object must implement so that it can participate in the style subsystem.
 IStateClient
mx.core The IStateClient interface defines the interface that components must implement to support view states.
 IStateClient2
mx.core The IStateClient2 interface defines the interface that components must implement to support Flex 4 view state semantics.
 IStyleClient
mx.styles This interface describes the properties and methods that an object must implement so that it can fully participate in the style subsystem.
 IStyleManager
mx.styles The IStyleManager class manages the following: Which CSS style properties the class inherits Which style properties are colors, and therefore get special handling A list of strings that are aliases for color values This interface was used by Flex 2.0.1.
 IStyleManager2
mx.styles The IStyleManager2 class manages the following: Which CSS style properties the class inherits Which style properties are colors, and therefore get special handling A list of strings that are aliases for color values
 IStyleModule
mx.styles Simple interface to manipulate style modules.
 ISystemManager
mx.managers An ISystemManager manages an "application window".
 ItemPendingError
mx.collections.errors This error is thrown when retrieving an item from a collection view requires an asynchronous call.
 ItemRenderer
spark.components.supportClasses The ItemRenderer class is the base class for Spark item renderers.
 ItemResponder
mx.collections The ItemResponder class provides a default implementation of the mx.rpc.IResponder interface.
 IToolTip
mx.core The IToolTip interface defines the API that tooltip-like components must implement in order to work with the ToolTipManager.
 IToolTipManagerClient
mx.managers Components that implement IToolTipManagerClient can have tooltips and must have a toolTip getter/setter.
 IUIComponent
mx.core The IUIComponent interface defines the basic set of APIs that you must implement to create a child of a Flex container or list.
 IUID
mx.core The IUID interface defines the interface for objects that must have Unique Identifiers (UIDs) to uniquely identify the object.
 IUITextField
mx.core The IUITextField interface defines the basic set of APIs for UITextField instances.
 IValidatorListener
mx.validators The interface that components implement to support the Flex data validation mechanism.
 IViewCursor
mx.collections Defines the interface for enumerating a collection view bi-directionally.
 IViewport
spark.core The IViewport interface is implemented by components that support a viewport.
 IVisualElement
mx.core The IVisualElement interface defines the minimum properties and methods required for a visual element to be laid out and displayed in a Spark container.
 IVisualElementContainer
mx.core The IVisualElementContainer interface defines the minimum properties and methods required for a container to manage Spark components for display.
 IXMLNotifiable
mx.utils The IXMLNotifiable interface.
 Keyframe
spark.effects.animation The Keyframe class defines the value of a property at a specific time during an effect.
 Label
spark.components Label is a low-level UIComponent that can render one or more lines of uniformly-formatted text.
 LabelUtil
spark.utils The LabelUtil class is used by components to determine the correct text to display for their renderers or sub-parts.
 LayoutBase
spark.layouts.supportClasses The LayoutBase class defines the base class for all Spark layouts.
 LayoutManager
mx.managers The LayoutManager is the engine behind Flex's measurement and layout strategy.
 Linear
spark.effects.easing The Linear class defines an easing with three phases: acceleration, uniform motion, and deceleration.
 List
spark.components The List control displays a vertical list of items.
 ListAccImpl
spark.accessibility ListAccImpl is the accessibility implementation class for spark.components.List.
 ListBase
spark.components.supportClasses The ListBase class is the base class for all components that support selection.
 ListBaseAccImpl
spark.accessibility ListBaseAccImpl is a superclass of the Spark ListAccImpl, DropDownListAccImpl, ComboBoxAccImpl, ButtonBarBaseAccImpl, and TabBarAccImpl.
 ListCollectionView
mx.collections The ListCollectionView class adds the properties and methods of the ICollectionView interface to an object that conforms to the IList interface.
 LoaderUtil
mx.utils The LoaderUtil class defines a utility method for use with Flex RSLs.
 LuminosityMaskShader
mx.graphics.shaderClasses Creates a blend shader that is equivalent to the luminosity masking option (also known as soft masking) available in Adobe Creative Suite tools.
 LuminosityShader
mx.graphics.shaderClasses Creates a blend shader that is equivalent to the 'Luminosity' blend mode for RGB premultiplied colors available in Adobe Creative Suite tools.
 MaskType
spark.core The MaskType class defines the possible values for the maskType property of the GraphicElement class.
 ModuleEvent
mx.events The ModuleEvent class represents the event object passed to the event listener for events related to dynamically-loaded modules.
 ModuleManager
mx.modules The ModuleManager class centrally manages dynamically loaded modules.
 MotionPath
spark.effects.animation The MotionPath class defines the collection of Keyframes objects for an effect, and the name of the property on the target to animate.
 Move
mx.effects The Move effect changes the position of a component over a specified time interval.
 MoveEvent
mx.events Represents event objects that are dispatched when a Flex component moves.
 MoveInstance
mx.effects.effectClasses The MoveInstance class implements the instance class for the Move effect.
 MultiValueInterpolator
spark.effects.interpolation The MultiValueInterpolator class interpolates each element of Arrays or Vectors of start and end elements separately, using another interpolator to do the interpolation for each element.
 NameUtil
mx.utils The NameUtil utility class defines static methods for creating names for Flex objects.
 NavigationUnit
spark.core The NavigationUnit class defines the possible values for the getVerticalScrollPositionDelta() and getHorizontalScrollPositionDelta() methods of the IViewport class.
 NumberInterpolator
spark.effects.interpolation The NumberInterpolator class provides interpolation between start and end values represented as Number instances.
 ObjectProxy
mx.utils This class provides the ability to track changes to an item managed by this proxy.
 ObjectUtil
mx.utils The ObjectUtil class is an all-static class with methods for working with Objects within Flex.
 OnDemandEventDispatcher
mx.utils OnDemandEventDispatcher serves as a base class for classes that dispatch events but expect listeners to be infrequent.
 OrderedObject
mx.utils OrderedObject acts as a wrapper to Object to preserve the ordering of the properties as they are added.
 OverlayDepth
spark.components.supportClasses The OverlayDepth class defines the default depth values for various overlay elements used by Flex.
 PostScaleAdapter
mx.containers.utilityClasses The PostScaleAdapter class is used as a compatibility layer for Flex 3 classes that rely on width, height, min, max, explicit, measured, and other properties to be determined after scaling is applied.
 Preloader
mx.preloaders The Preloader class is used by the SystemManager to monitor the download and initialization status of a Flex application.
 PropertyChangeEvent
mx.events The PropertyChangeEvent class represents the event object passed to the event listener when one of the properties of an object has changed, and provides information about the change.
 PropertyChangeEventKind
mx.events The PropertyChangeEventKind class defines the constant values for the kind property of the PropertyChangeEvent class.
 PropertyChanges
mx.effects.effectClasses The PropertyChanges class defines the start and end values for a set of properties of a target component of a transition.
 Range
spark.components.supportClasses The Range class holds a value and an allowed range for that value, defined by minimum and maximum properties.
 RendererExistenceEvent
spark.events The RendererExistenceEvent class represents events that are dispatched when a renderer of a Spark DataGroup is added or removed.
 RepeatBehavior
spark.effects.animation The RepeatBehavior class defines constants for use with repeatBehavior property of the Animate and Animation classes.
 Request
mx.events This is an event that is expects its data property to be set by a responding listener.
 ResizeEvent
mx.events Represents event objects that are dispatched when the size of a Flex component changes.
 ResizeMode
spark.components The ResizeMode class defines an enumeration of the modes a component uses to resize its children in the dimensions specified by the layout system.
 ResourceBundle
mx.resources Provides an implementation of the IResourceBundle interface.
 ResourceEvent
mx.events The ResourceEvent class represents an Event object that is dispatched when the ResourceManager loads the resource bundles in a resource module by calling the loadResourceModule() method.
 ResourceManager
mx.resources This class is used to get a single instance of the IResourceManager implementation.
 RichEditableText
spark.components RichEditableText is a low-level UIComponent for displaying, scrolling, selecting, and editing richly-formatted text.
 RichEditableTextAccImpl
spark.accessibility RichEditableTextAccImpl is the accessibility implementation class for spark.components.RichEditableText.
 RichText
spark.components RichText is a low-level UIComponent that can display one or more lines of richly-formatted text and embedded images.
 RoundedRectangle
mx.geom RoundedRectangle represents a Rectangle with curved corners
 RSLEvent
mx.events The RSLEvent class represents an event object used by the DownloadProgressBar class when an RSL is being downloaded by the Preloader class.
 SandboxMouseEvent
mx.events This is an event sent between applications in different security sandboxes to notify listeners about mouse activity in another security sandbox.
 SaturationShader
mx.graphics.shaderClasses Creates a blend shader that is equivalent to the 'Saturation' blend mode for RGB premultiplied colors available in Adobe Creative Suite tools.
 ScrollBar
mx.controls.scrollClasses The ScrollBar class is the base class for the HScrollBar and VScrollBar controls.
 ScrollBarBase
spark.components.supportClasses The ScrollBarBase class helps to position the portion of data that is displayed when there is too much data to fit in a display area.
 ScrollBarDirection
mx.controls.scrollClasses The ScrollBarDirection class defines the values for the direction property of the ScrollBar control.
 Scroller
spark.components The Scroller component displays a single scrollable component, called a viewport, and horizontal and vertical scroll bars.
 ScrollEvent
mx.events Represents events that are dispatched by the ScrollBar class.
 ScrollEventDetail
mx.events Constants for the values of the detail property of a ScrollEvent.
 ScrollEventDirection
mx.events Constants for the values of the direction property of a ScrollEvent.
 ScrollPolicy
mx.core Values for the horizontalScrollPolicy and verticalScrollPolicy properties of the Container and ScrollControlBase classes.
 ScrollThumb
mx.controls.scrollClasses The ScrollThumb class defines the thumb of a ScrollBar control.
 SimpleMotionPath
spark.effects.animation The SimpleMotionPath class specifies the name of a property, and the values that that property takes over time, for instances of the Animate effect.
 Sine
spark.effects.easing The Sine class defines easing functionality using a Sine function.
 Skin
spark.components.supportClasses The Skin class defines the base class for all skins used by skinnable components.
 SkinnableComponent
spark.components.supportClasses The SkinnableComponent class defines the base class for skinnable components.
 SkinnableContainerBase
spark.components.supportClasses Base class for skinnable container components.
 SkinnableDataContainer
spark.components The SkinnableDataContainer class is the base container class for data items.
 SkinnableTextBase
spark.components.supportClasses The base class for skinnable components, such as the Spark TextInput and TextArea, that include an instance of RichEditableText in their skin to provide rich text display, scrolling, selection, and editing.
 SoftLightShader
mx.graphics.shaderClasses Creates a blend shader that is equivalent to the 'Soft Light' blend mode for RGB premultiplied colors available in Adobe Creative Suite tools.
 Sort
mx.collections Provides the sorting information required to establish a sort on an existing view (ICollectionView interface or class that implements the interface).
 SortError
mx.collections.errors This error is thrown when a Sort class is not configured properly; for example, if the find criteria are invalid.
 SortField
mx.collections Provides the sorting information required to establish a sort on a field or property in an existing view.
 State
mx.states The State class defines a view state, a particular view of a component.
 StateChangeEvent
mx.events The StateChangeEvent class represents an event that is dispatched when the currentState property of a component changes.
 StringUtil
mx.utils The StringUtil utility class is an all-static class with methods for working with String objects within Flex.
 StyleEvent
mx.events The StyleEvent class represents an event object used by the StyleManager class when a style SWF is being downloaded.
 StyleManager
mx.styles The StyleManager class manages the following: Which CSS style properties the class inherits Which style properties are colors, and therefore get special handling A list of strings that are aliases for color values
 StyleProxy
mx.styles Wraps an object that implements the IAdvancedStyleClient interface.
 SystemManager
mx.managers The SystemManager class manages an application window.
 TextBase
spark.components.supportClasses The base class for Spark text controls such as Label and RichText which display text using CSS styles for the default format.
 TextBaseAccImpl
spark.accessibility TextBaseAccImpl is the accessibility implementation class for spark.components.TextBase.
 TextFlowUtil
spark.utils TextFlowUtil is a utility class which provides methods for importing a TextFlow from, and exporting a TextFlow to, the markup language used by the Text Layout Framework.
 TextInput
spark.components TextInput is a text-entry control that lets users enter and edit a single line of uniformly-formatted text.
 TextOperationEvent
spark.events The TextOperationEvent class represents events that are dispatched when text content changes due to user operations such as inserting characters, backspacing, pasting, or changing text attributes.
 TextSelectionHighlighting
spark.components This class specifies the allowed values for the selectionHighlighting property of the RichEditableText control, and controls that use RichEditableText as a subcomponent (Spark TextInput and Spark TextArea).
 ToolTip
mx.controls The ToolTip control lets you provide helpful information to your users.
 ToolTipEvent
mx.events The ToolTipEvent class represents ToolTip events, which are generated by the ToolTipManager class.
 ToolTipManager
mx.managers The ToolTipManager lets you set basic ToolTip and error tip functionality, such as display delay and the disabling of ToolTips.
 TrackBase
spark.components.supportClasses The TrackBase class is a base class for components with a track and one or more thumb buttons, such as Slider and ScrollBar.
 TrackBaseEvent
spark.events Represents events that are dispatched from a TrackBase component.
 Transform
mx.geom The mx.geom.Transform class adds synchronization support on top of the flash.geom.Transform class.
 TransformOffsets
mx.geom A CompoundTransform represents a 2D or 3D matrix transform.
 Transition
mx.states The Transition class defines a set of effects that play in response to a change of view state.
 Tween
mx.effects The Tween class defines a tween, a property animation performed on a target object over a period of time.
 TweenEffect
mx.effects The TweenEffect class is the superclass for all effects that are based on the Tween object.
 TweenEffectInstance
mx.effects.effectClasses The TweenEffectInstance class implements the instance class for the TweenEffect.
 TweenEvent
mx.events Represents event objects that are specific to Flex tween effects.
 UIComponent
mx.core The UIComponent class is the base class for all visual components, both interactive and noninteractive.
 UIComponentAccProps
mx.accessibility UIComponentAccProps is a subclass of AccessibilityProperties for use by various UIComponents.
 UIComponentCachePolicy
mx.core The ContainerCreationPolicy class defines the constant values for the cachePolicy property of the UIComponent class.
 UIComponentDescriptor
mx.core A UIComponentDescriptor instance encapsulates the information that you specified in an MXML tag for an instance of a visual component.
 UIDUtil
mx.utils The UIDUtil class is an all-static class with methods for working with UIDs (unique identifiers) within Flex.
 UITextField
mx.core The UITextField class defines the component used by many Flex components to display text.
 UITextFormat
mx.core The UITextFormat class represents character formatting information for the UITextField class.
 ValidationResult
mx.validators The ValidationResult class contains the results of a validation.
 ValidationResultEvent
mx.events The ValidationResultEvent class represents the event object passed to the listener for the valid validator event or the invalid validator event.
 VScrollBar
mx.controls The VScrollBar (vertical ScrollBar) control lets you control the portion of data that is displayed when there is too much data to fit in a display area.
 VScrollBar
spark.components The VScrollBar (vertical scrollbar) control lets you control the portion of data that is displayed when there is too much data to fit vertically in a display area.
 XMLNotifier
mx.utils Used for watching changes to XML and XMLList objects.
 Zoom
mx.effects The Zoom effect zooms the object in or out on a center point.
 ZoomInstance
mx.effects.effectClasses The ZoomInstance class implements the instance class for the Zoom effect.