 import spark.core.DisplayObjectSharingMode;
 import spark.core.IGraphicElement;
 import spark.core.MaskType;
-import spark.primitives.supportClasses.shaders.ColorBurnShader;
-import spark.primitives.supportClasses.shaders.ColorDodgeShader;
-import spark.primitives.supportClasses.shaders.ColorShader;
-import spark.primitives.supportClasses.shaders.ExclusionShader;
-import spark.primitives.supportClasses.shaders.HueShader;
-import spark.primitives.supportClasses.shaders.LuminosityMaskShader;
-import spark.primitives.supportClasses.shaders.LuminosityShader;
-import spark.primitives.supportClasses.shaders.SaturationShader;
-import spark.primitives.supportClasses.shaders.SoftLightShader; 
 
 use namespace mx_internal;
 

     */
    public function set blendMode(value:String):void
    {
        if (blendModeExplicitlySet && value == _blendMode)
            return;

        //The default blendMode in FXG is 'auto'. There are only
        //certain cases where this results in a rendering difference,
        //one being when the alpha of the Group is > 0 and < 1. In that
        //case we set the blendMode to layer to avoid the performance
        //overhead that comes with a non-normal blendMode. 
        
        if (alpha > 0 && alpha < 1 && !blendModeExplicitlySet && value == "auto")
        {
            if (value != BlendMode.LAYER)
            {
                _blendMode = BlendMode.LAYER;
                blendModeChanged = true;
                invalidateProperties();
            }
        }
        else if ((alpha == 1 || alpha == 0) && !blendModeExplicitlySet && value == "auto")
        {
            if (value != BlendMode.NORMAL)
            {
                _blendMode = BlendMode.NORMAL;
                blendModeChanged = true;
                invalidateProperties();
            }
        }
        else 
        {
            _blendMode = value;
            
            // If one of the non-native Flash blendModes is set, 
            // record the new value and set the appropriate 
            // blendShader on the display object. 
            if (value == "colordodge" || 
                value =="colorburn" || value =="exclusion" || 
                value =="softlight" || value =="hue" || 
                value =="saturation" || value =="color" 
                || value =="luminosity")
                blendShaderChanged = true;
            else 
                blendModeChanged = true;
                
            blendModeExplicitlySet = true;
            invalidateProperties(); 
        }
    }

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

                    displayObject.alpha = _effectiveAlpha;
            }  

            if (blendModeChanged || displayObjectChanged)
            {
                blendModeChanged = false;
                
                // Figure out the correct value to push down 
                // to the displayObject's blendMode 
                if (_blendMode == "auto")
                {
                    if (alpha == 0 || alpha == 1) 
                        displayObject.blendMode = BlendMode.NORMAL;
                    else
                        displayObject.blendMode = BlendMode.LAYER;
                }
                
                else if (!isAIMBlendMode(_blendMode))
                {
                    displayObject.blendMode = _blendMode;
                }
                
                // The blendMode is neither a native value, 
                // or the 'auto' value so lets set blendMode 
                // to normal.  
                else
                {
                    displayObject.blendMode = "normal"; 
                }
                
                if (blendShaderChanged) 
                {
                    // The graphic element's blendMode was set to a non-Flash 
                    // blendMode. We mimic the look by instantiating the 
                    // appropriate shader class and setting the blendShader
                    // property on the displayObject. 
                    blendShaderChanged = false; 
                    
                    switch(_blendMode)
                    {
                        case "color": 
                        {
                            displayObject.blendShader = new ColorShader();
                            break; 
                        }
                        case "colordodge":
                        {
                            displayObject.blendShader = new ColorDodgeShader();
                            break; 
                        }
                        case "colorburn":
                        {
                            displayObject.blendShader = new ColorBurnShader();
                            break; 
                        }
                        case "exclusion":
                        {
                            displayObject.blendShader = new ExclusionShader();
                            break; 
                        }
                        case "hue":
                        {
                            displayObject.blendShader = new HueShader();
                            break; 
                        }
                        case "luminosity":
                        {
                            displayObject.blendShader = new LuminosityShader();
                            break; 
                        }
                        case "saturation": 
                        {
                            displayObject.blendShader = new SaturationShader();
                            break; 
                        }
                        case "softlight":
                        {
                            displayObject.blendShader = new SoftLightShader();
                            break; 
                        }
                    }
                }
            }
