 public class AccImpl extends AccessibilityImplementation
 {
     include "../core/Version.as";
-        
+
     //--------------------------------------------------------------------------
     //
     //  Class methods

        // Accessible name if it exists, else label text.
        var f:String = "";
        if (formItem.accessibilityProperties)
        {
            f = formItem.accessibilityProperties.name
            // The purpose of the following two lines is to
            // make the FormItem "silent" so that its MSAA Name doesn't get
            // spoken. It doesn't need to be spoken since the Name of each
            // control inside the FormItem includes the FormItem's Name.
            if (formItem.itemLabel && formItem.itemLabel.accessibilityEnabled)
                formItem.itemLabel.accessibilityEnabled = false;
        }
        if (f == "")
            f = formItem.label;
            
        formName = joinWithSpace(formName, f);

        return formName;
    }

    //--------------------------------------------------------------------------

    }
    
    /**
     *  @private
     *  Data structure internal to the following getDefinitions() function:
     *  These are the defined types and the classes they map to.
     *  Structure of an entry: typeName: className, className, ...
     *  Newest classes first in case this helps performance for newer code.
     */
    private static var typeMap:Object =
    {
        "Container": [
            "spark.components.SkinnableContainer",
            "mx.core.Container"
        ],
        "Form": [
            "spark.components.Form",
            "mx.containers.Form"
        ],
        "FormHeading": [
            "spark.components.FormHeading",
            "mx.containers.FormHeading"
        ],
        "FormItem": [
            "spark.components.FormItem",
            "mx.containers.FormItem"
        ],
        "FormItemLabel": [
            // No Spark equivalent for this.
            "mx.controls.FormItemLabel"
        ],
        "ScrollBar": [
            "mx.controls.scrollClasses.ScrollBar",
            "spark.components.supportClasses.ScrollBarBase"
        ]
    };

    /**
     *  @private
     *  
     *  Get the class definition(s) corresponding to a predefined type. The
     *  definitions are looked up in the specified moduleFactory. If no
     *  moduleFactory is given, then the definitions are looked up in
     *  ApplicationDomain.currentDomain.
     *  The types are defined for this function by the above typeMap structure.
     * 
     *  @param typeName Type of the class(es) to get.
     *  Passing an invalid typeName will raise an error.
     *  @param moduleFactory The moduleFactory that specifies the application 
     *  domain to use to find the definitions. If moduleFactory is null, then
     *  ApplicationDomain.currentDomain is used as a fall back.
     * 
     *  return The list of definitions found.
     * 
     */ 
    mx_internal static function getDefinitions(typeName:String, moduleFactory:IFlexModuleFactory):Array
    {
        var defs:Array = [];
        var thisClass:Class;
        for each (var className:String in typeMap[typeName])
        {
            thisClass = Class(getDefinition(className, moduleFactory));
            if (thisClass)
                defs.push(thisClass);
        }
        return defs;
    }

    /**
     *  @private
     *  
     *  Find out if an object is one of a set of classes, and return the
     *  class if so.
     * 
     *  @param obj Object to check against the list of classes.
     *  @param classes List of classes to check against.
     * 
     *  return The found class or null.
     * 
     */ 
    mx_internal static function getMatchingDefinition(obj:Object, classes:Array):Class
    {
        if (!obj)
            return null;
        for each (var thisClass:Class in classes)
        {
            if (obj is thisClass)
                return thisClass;
        }
        return null;
    }

    /**
    *  @private
    *  Finds an ancestor of a component matching a rule.
    *
    *  @param component The component from which to start (included in the checking too).
    *  @param f The function that returns true ffor a match.
    *  The function should be defined as function (component:UIComponent):Boolean.
    *
    *  @return The UIComponent first matching the rule or null if none do.
     */
    mx_internal static function findMatchingAncestor(component:Object, f:Function):UIComponent
    {
        while (component && (component is UIComponent)
               && !(component is ISystemManager) && component != UIComponent(component).root)
        {
            if (f(component))
                return UIComponent(component);
            component = UIComponent(component).parent;
        }
        return null;
    }

    /**
     *  Returns true if an ancestor of the component has enabled set to false.
     *  The given component itself is not checked.
     *
     *  @param component The UIComponent to check for a disabled ancestor.
     *
     *  @return true if the component has a disabled ancestor.
     */
    public static function isAncestorDisabled(component:UIComponent):Boolean
    {
        return findMatchingAncestor(component.parent, isComponentDisabled) != null;
    }
    
    /**
     *  @private
     *  Check if a component is disabled.
     *  Used in calls to findMatchingAncestor().
     *
     *  @param component The UIComponent to check.
     *
     *  @return true if the component is disabled.
     */
    mx_internal static function isComponentDisabled(component:UIComponent):Boolean
    {
        return !component.enabled;
    }

    /**
     *  @private
     *  Check if a component is a form..
     *  Used in calls to findMatchingAncestor().
     *
     *  @param component The UIComponent to check.
     *
     *  @return true if the component is a form..
     */
    mx_internal static function isForm(component:UIComponent):Boolean
    {
        var formClasses:Array = getDefinitions("Form", component.moduleFactory);
        return getMatchingDefinition(component, formClasses) != null;
    }

    /**
     *  @private
     *  Check if a component is a form heading.
     *  Used in calls to findMatchingAncestor().
     *
     *  @param component The UIComponent to check.
     *
     *  @return true if the component is a form heading.
     */
        mx_internal static function isFormHeading(component:UIComponent):Boolean
        {
            var formHeadingClasses:Array = getDefinitions("FormHeading", component.moduleFactory);
        return getMatchingDefinition(component, formHeadingClasses) != null;
        }

    /**
     *  @private
     *  Check if a component is a form item (meaning a FormItem class).
     *  Used in calls to findMatchingAncestor().
     *
     *  @param component The UIComponent to check.
     *
     *  @return true if the component is a FormItem.
     */
    mx_internal static function isFormItem(component:UIComponent):Boolean
    {
        var formItemClasses:Array = getDefinitions("FormItem", component.moduleFactory);
        return getMatchingDefinition(component, formItemClasses) != null;
    }

    /**
     *  Method for supporting Form Accessibility.
     *  Called from get_accName() in this AccImpl class.
     *  Also called from the UIComponentAccProps constructor.
     *  
     *  @langversion 3.0
     *  @playerversion Flash 9
