*

*  Licensed to the Apache Software Foundation (ASF) under one or more

*  contributor license agreements.  See the NOTICE file distributed with

*  this work for additional information regarding copyright ownership.

*  The ASF licenses this file to You under the Apache License, Version 2.0

*  (the "License"); you may not use this file except in compliance with

*  the License.  You may obtain a copy of the License at

*

*      http://www.apache.org/licenses/LICENSE-2.0

*

*  Unless required by applicable law or agreed to in writing, software

*  distributed under the License is distributed on an "AS IS" BASIS,

*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

*  See the License for the specific language governing permissions and

*  limitations under the License.

*

*/

* Transcodes an FXG DOM into a tree of SWF DefineSprites which use SWF graphics

* primitives to draw the document.

* Note that in this implementation, since FTE based text

* has no equivalent in SWF tags, text nodes are ignored.

*

* @author Peter Farland

*/

    protected HashMap<String, DefineSprite> definitions;

    protected Stack<DefineSprite> spriteStack;

    protected FXGResourceResolver resourceResolver;

    protected int spriteCount;

    protected static Random random = new Random();

    /**

     * Create a new instance of the transcoder.

     *

     * @return the transcoder

     */

    public FXG2SWFTranscoder newInstance()

    {

        return new FXG2SWFTranscoder();

    }

   

    /**

     * {@inheritDoc}

     */

    public void setResourceResolver(FXGResourceResolver resolver)

    {

        resourceResolver = resolver;

    }

    /**

     * {@inheritDoc}

     */

    public Object transcode(FXGNode fxgNode)

    {

        GraphicNode node = (GraphicNode)fxgNode;

        DefineSprite sprite = createDefineSprite("Graphic");

        spriteStack.push(sprite);

        // Process mask (if present)

        if (node.mask != null)

            mask(node, sprite);

        // Handle 'scale 9' grid definition

        if (node.definesScaleGrid())

        {

            DefineScalingGrid grid = createDefineScalingGrid(node.getScalingGrid());

            grid.scalingTarget = sprite;

            sprite.scalingGrid = grid;

        }

        // Process child nodes

        if (node.children != null)

            graphicContentNodes(node.children);

        spriteStack.pop();

        return sprite;

    }

    /**

     * Instantiates a new transcoder.

     */

    public FXG2SWFTranscoder()

    {

        spriteStack = new Stack<DefineSprite>();

    }

   

    private PlaceObject bitmapWithClip(DefineBits imageTag, BitmapGraphicNode node)

    {

        GraphicContext context = node.createGraphicContext();

        //process the filters later to avoid masking

        List<FilterNode> filters = null;

        if (context.filters != null)      

        {  

            filters = context.filters;

            context.filters = null;

            DefineSprite filterSprite = createDefineSprite("MaskFilter");

            spriteStack.push(filterSprite);

        }

       

        DefineSprite imageSprite = createDefineSprite("BitmapGraphic");

        spriteStack.push(imageSprite);

        // First, generate the clipping mask

        DefineSprite clipSprite = createDefineSprite("BitmapGraphic_Clip");

        spriteStack.push(clipSprite);

        double width = (imageTag.width < node.width) ? imageTag.width : node.width;

        double height = (imageTag.height < node.height) ? imageTag.height : node.height;

        List<ShapeRecord> shapeRecords = ShapeHelper.rectangle(0.0, 0.0, width, height);

        DefineShape clipShape = createDefineShape(null, shapeRecords, new SolidColorFillNode(), null, context.getTransform());

        placeObject(clipShape, new GraphicContext());

        spriteStack.pop();

       

        //place the clipping mask in the imageSprite

        PlaceObject po3clip = placeObject(clipSprite, context);

        po3clip.setClipDepth(po3clip.depth+1);

       

        // Then, process the image

        DefineShape imageShape = ImageHelper.createShapeForImage(imageTag, node);

        placeObject(imageShape, context);       

        spriteStack.pop();

       

        PlaceObject po3 = placeObject(imageSprite, new GraphicContext());

       

        // If filters were not processed, place the topmost sprite in display list and apply filters

        // This is done to force processing of masks before filters

        if (filters != null)

        {

            DefineSprite sprite = spriteStack.pop();   

            GraphicContext gc = new GraphicContext();

            gc.filters = filters;

            PlaceObject poFilter = placeObject(sprite, gc);

            return poFilter;           

        }

        return po3;

    }

   

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

    //

    // Graphic Content Nodes

    //

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

    protected PlaceObject bitmap(BitmapGraphicNode node)

    {

        GraphicContext context = node.createGraphicContext();

        String source = parseSource(node.source);

        if (source == null)

        {

            // Exception: Missing source attribute in <BitmapGraphic> or <BitmapFill>.

            throw new FXGException(node.getStartLine(), node.getStartColumn(), "MissingSourceAttribute");

        }

        DefineBits imageTag = createDefineBits(node, source);

       

        if ((node.visible) && (!node.isPartofClipMask))

        {

      

            DefineShape imageShape;

            ScalingGrid scalingGrid = context.scalingGrid;

            if (scalingGrid != null)

            {

                Rect grid = TypeHelper.rect(scalingGrid.scaleGridLeft, scalingGrid.scaleGridTop, scalingGrid.scaleGridRight, scalingGrid.scaleGridBottom);

                imageShape = ImageHelper.create9SlicedShape(imageTag, grid, Double.NaN, Double.NaN);

                PlaceObject po3 = placeObject(imageShape, context);

                return po3;

            }

            else

            {

              if (ImageHelper.bitmapImageNeedsClipping(imageTag, node))

              {

                PlaceObject p03 = bitmapWithClip(imageTag, node);

                return p03;

              }

              else

              {

                imageShape = ImageHelper.createShapeForImage(imageTag, node);

                PlaceObject po3 = placeObject(imageShape, context);

                return po3;

              }

            }           

        }

        else

        {

          if (!ImageHelper.bitmapImageNeedsClipping(imageTag, node))

          {          

               double width = (Double.isNaN(node.width)) ? imageTag.width : node.width;

                 double height = (Double.isNaN(node.height)) ? imageTag.height : node.height;

             List<ShapeRecord>  shapeRecords = ShapeHelper.rectangle(0.0, 0.0, width, height);       

               DefineShape shape = createDefineShape(null, shapeRecords, new SolidColorFillNode(), null, context.getTransform());

             PlaceObject po3 = placeObject(shape, context);

             return po3;

          }

          else

          {

                double width = ((imageTag.width < node.width) || Double.isNaN(node.width)) ? imageTag.width : node.width;

                double height = ((imageTag.height < node.height) || (Double.isNaN(node.height))) ? imageTag.height : node.height;

              List<ShapeRecord>  shapeRecords = ShapeHelper.rectangle(0.0, 0.0, width, height);       

                 DefineShape shape = createDefineShape(null, shapeRecords, new SolidColorFillNode(), null, context.getTransform());

              PlaceObject po3 = placeObject(shape, context);

              return po3;

          }

        }

    }

    protected void graphicContentNodes(List<GraphicContentNode> nodes)

    {

        if (nodes == null) return;

        Iterator<GraphicContentNode> iterator = nodes.iterator();

        while (iterator.hasNext())

        {

            GraphicContentNode node = iterator.next();

            graphicContentNode(node);

        }

    }

    protected PlaceObject graphicContentNode(GraphicContentNode node)

    {

        PlaceObject po3 = null;

      if (!node.visible)

        {

            ColorTransformNode ct = new ColorTransformNode();

            ct.alphaMultiplier = 0;

            ct.alphaOffset = 0;

            ct.blueMultiplier = 1;

            ct.blueOffset = 0;

            ct.greenMultiplier = 1;

            ct.greenOffset = 0;

            ct.redMultiplier = 1;

            ct.redOffset = 0;

            node.colorTransform = ct;

           

            if (node instanceof AbstractShapeNode)

            {

                AbstractShapeNode shapeNode = (AbstractShapeNode)node;

                shapeNode.fill = null;

                shapeNode.stroke = null;

            }

           

        }

        if (node instanceof GroupNode)

        {

            group((GroupNode)node);

        }

        else

        {

            if (node.blendMode == BlendMode.AUTO)

                node.blendMode = BlendMode.NORMAL;

           

            // For non-group nodes, we process mask to clip only this shape

            // node. Process the mask first to ensure the depth is correct.

            List<FilterNode> filters = null;

            if (node.mask != null)

            {

                // Remove the filters from context and process them later to force Flash Player to process the masks first

                if (node.filters != null)

                {  

                    filters = node.filters;

                    node.filters = null;

                    DefineSprite filterSprite = createDefineSprite("MaskFilter");

                    spriteStack.push(filterSprite);

                }

                DefineSprite parentSprite = spriteStack.peek();

                mask(node, parentSprite);

            }

           

            if (node instanceof EllipseNode)

                po3 = ellipse((EllipseNode)node);

            else if (node instanceof LineNode)

                po3 = line((LineNode)node);

            else if (node instanceof PathNode)

                po3 = path((PathNode)node);

            else if (node instanceof RectNode)

                po3 = rect((RectNode)node);

            else if (node instanceof PlaceObjectNode)

                po3 = placeObjectInstance((PlaceObjectNode)node);

            else if (node instanceof BitmapGraphicNode)

                po3 = bitmap((BitmapGraphicNode)node);

            else if (node instanceof TextGraphicNode)

                po3 = text((TextGraphicNode)node);

            else if (node instanceof RichTextNode)

                po3 = richtext((RichTextNode)node);

           

            // If filters were not processed, place the topmost sprite in display list and apply filters

            // This is done to force processing of masks before filters

            if (filters != null)

            {

                DefineSprite sprite = spriteStack.pop();   

                GraphicContext gc = new GraphicContext();

                gc.filters = filters;

                PlaceObject poFilter = placeObject(sprite, gc);

                return poFilter;           

            }

        }

        return po3;

    }

    protected PlaceObject ellipse(EllipseNode node)

    {

        // Note that we will apply node.x and node.y as a translation operation

        // in the PlaceObject3 Matrix and instead start the shape from the

        // origin (0.0, 0.0).

        Ellipse2D.Double ellipse = new Ellipse2D.Double(0.0, 0.0, node.width, node.height);

        ShapeBuilder builder = new ShapeBuilder();

        ShapeIterator iterator = new PathIteratorWrapper(ellipse.getPathIterator(null));

        builder.processShape(iterator);

        Shape shape = builder.build();

        return placeDefineShape(node, shape.shapeRecords, node.fill, node.stroke, node.createGraphicContext());

       

    }

    protected PlaceObject group(GroupNode node)

    {

      //handle blendMode "auto"

        if (node.blendMode == BlendMode.AUTO)

        {

          if ((node.alpha == 0) || (node.alpha == 1))

            node.blendMode = BlendMode.NORMAL;

          else

          {           

            if (node.isForMobile())

                    node.blendMode = BlendMode.NORMAL;

            else

              node.blendMode = BlendMode.LAYER;

          }

         

         

        }

       

        DefineSprite groupSprite = createDefineSprite("Group");

        GraphicContext context = node.createGraphicContext();

       

        // Handle 'scale 9' grid definition

        if (node.definesScaleGrid())

        {

            DefineScalingGrid grid = createDefineScalingGrid(context.scalingGrid);

            grid.scalingTarget = groupSprite;

            groupSprite.scalingGrid = grid;

        }

        PlaceObject po3 = placeObject(groupSprite, context);

        spriteStack.push(groupSprite);

        // First, process mask (if present)

        List <FilterNode> filters = null;

        if (node.mask != null)

        {   

            // Remove the filters from context and process them later to force Flash Player to process the masks first

            filters = node.filters;

            if (filters == null)

            {

                List<GraphicContentNode> children = node.children;

                if (children != null)

                {

                    GraphicContentNode gcNode0 = (GraphicContentNode) children.get(0);

                    filters = gcNode0.filters;

                    if (filters != null)

                    {

                        //check if all the nodes share the same filter

                        for (int i = 1; ((i < children.size()) && filters!= null); i++)

                        {

                            GraphicContentNode gcNodeI = (GraphicContentNode) children.get(i);

                            if (gcNodeI.filters != filters)

                                filters = null;

                        }

                    }

                    if (filters != null)

                    {

                        for (int i = 0; (i < children.size()) ; i++)

                        {

                            GraphicContentNode gcNodeI = (GraphicContentNode) children.get(i);

                            gcNodeI.filters = null;

                        }                       

                    }

                   

                }

            }

            else

            {

                node.filters = null;

            }

            if (filters != null)      

            {   

                DefineSprite filterSprite = createDefineSprite("MaskFilter");

                spriteStack.push(filterSprite);

            }

            DefineSprite sprite = spriteStack.peek();

            mask(node, sprite);

        }

        // Then process child nodes.

        if (node.children != null)

            graphicContentNodes(node.children);

       

        // If filters were not processed, place the topmost sprite in display list and apply filters

        // This is done to force processing of masks before filters

        if (filters != null)

        {

            DefineSprite sprite = spriteStack.pop();   

            GraphicContext gc = new GraphicContext();

            gc.filters = filters;

            PlaceObject poFilter = placeObject(sprite, gc);

            return poFilter;           

        }

        spriteStack.pop();

        return po3;

    }

    protected PlaceObject line(LineNode node)

    {

        List<ShapeRecord> shapeRecords = ShapeHelper.line(node.xFrom, node.yFrom, node.xTo, node.yTo);

        GraphicContext context = node.createGraphicContext();

        PlaceObject po3 = placeDefineShape(node, shapeRecords, node.fill, node.stroke, context);

        return po3;

    }

    protected PlaceObject mask(MaskableNode node, DefineSprite parentSprite)

    {

        PlaceObject po3 = null;

        MaskingNode mask = node.getMask();

        if (mask instanceof GroupNode)

        {

            // According to FXG Spec.: The masking element inherits the target

            // group's coordinate space, as though it were a direct child

            // element. In the case when mask is inside a shape, it doesn't

            // automatically inherit the coordinates from the shape node

            // but inherits from its parent node which is also parent of

            // the shape node. To fix it, specifically concatenating the

            // shape node matrix to the masking node matrix.

            if (!(node instanceof GroupNode || node instanceof GraphicNode))

            {

                FXGMatrix nodeMatrix = null;

                MatrixNode matrixNodeShape = ((GraphicContentNode)node).matrix;

                if (matrixNodeShape == null)

                    // Convert shape node's discreet transform attributes to

                    // matrix.

                    nodeMatrix = FXGMatrix.convertToMatrix(((GraphicContentNode)node).scaleX, ((GraphicContentNode)node).scaleY, ((GraphicContentNode)node).rotation, ((GraphicContentNode)node).x, ((GraphicContentNode)node).y);

                else

                    nodeMatrix = new FXGMatrix(matrixNodeShape);

                // Get masking node matrix.

                MatrixNode matrixNodeMasking = ((GraphicContentNode)mask).matrix;

                // Create a new MatrixNode if the masking node doesn't have one.

                if (matrixNodeMasking == null)

                {

                    // Convert masking node's transform attributes to matrix

                    // so we can concatenate the shape node's matrix to it.

                    ((GraphicContentNode)mask).convertTransformAttrToMatrix();

                    matrixNodeMasking = ((GraphicContentNode)mask).matrix;

                }

                FXGMatrix maskMatrix = new FXGMatrix(matrixNodeMasking);

                // Concatenate the shape node's matrix to the masking node's

                // matrix.

                maskMatrix.concat(nodeMatrix);

                // Set the masking node's matrix with the concatenated values.

                maskMatrix.setMatrixNodeValue(matrixNodeMasking);

            }

           

            markLeafNodesAsMask(node, (GroupNode) mask);

            po3 = group((GroupNode)mask);

        }

        else if (mask instanceof PlaceObjectNode)

        {

            po3 = placeObjectInstance((PlaceObjectNode)mask);

        }

        if (po3 != null)

        {

            int clipDepth = 1;

            // If we had a graphic or group, clip the depths for all children.

            if (node instanceof GroupNode)

            {

                GroupNode group = (GroupNode)node;

                if (group.children != null)

                    clipDepth = parentSprite.depthCounter + group.children.size();

            }

            else if (node instanceof GraphicNode)

            {

                GraphicNode graphic = (GraphicNode)node;

                if (graphic.children != null)

                    clipDepth = parentSprite.depthCounter + graphic.children.size();

            }

            // ... otherwise, just clip the shape itself.

            else

            {

                clipDepth = po3.depth + 1;

            }

            po3.setClipDepth(clipDepth);

            if (node.getMaskType() == MaskType.ALPHA)

            {

                po3.setCacheAsBitmap(true);

            }

        }

        return po3;

    }

    protected PlaceObject path(PathNode node)

    {

        List<ShapeRecord> shapeRecords = ShapeHelper.path(node, (node.fill != null));

        GraphicContext context = node.createGraphicContext();

        Winding winding[] = new Winding[1];

        winding[0] = node.winding;

        PlaceObject po3 = placeDefineShape(node, shapeRecords, node.fill, node.stroke, context, winding);

        return po3;

    }

    protected void setPixelBenderBlendMode(PlaceObject po, BlendMode blendMode)

    {

       

    }

   

    protected void setAlphaMask(PlaceObject po)

    {

        po.setCacheAsBitmap(true);

    }

   

    protected void setLuminosityMask(PlaceObject po)

    {

      

    }

   

    protected PlaceObject placeObject(DefineTag symbol, GraphicContext context)

    {

        DefineSprite sprite = spriteStack.peek();

        PlaceObject po3 = new PlaceObject(Tag.stagPlaceObject3);

        // po3.setName(name);

        po3.setRef(symbol);

        po3.depth = ++sprite.depthCounter;

        if (context.blendMode != null)

        {

            if (!context.blendMode.needsPixelBenderSupport())

            {

                int blendMode = createBlendMode(context.blendMode);

                po3.setBlendMode(blendMode);

            }

            else

            {

                setPixelBenderBlendMode(po3, context.blendMode);

            }

        }

       

        if (context.filters != null)

        {

            List<Filter> filters = createFilters(context.filters);

            po3.setFilterList(filters);

        }

        // FXG angles are always clockwise.

        Matrix matrix = context.getTransform().toSWFMatrix();

        po3.setMatrix(matrix);

        if (context.colorTransform != null)

        {

            ColorTransformNode t = context.colorTransform;

            CXFormWithAlpha cx = TypeHelper.cxFormWithAlpha(t.alphaMultiplier, t.redMultiplier, t.greenMultiplier, t.blueMultiplier, t.alphaOffset, t.redOffset, t.greenOffset, t.blueOffset);

            po3.setCxform(cx);

        }

       

        if (context.maskType == MaskType.ALPHA)

        {

            setAlphaMask(po3);

        }

        else if (context.maskType == MaskType.LUMINOSITY)

        {

            setLuminosityMask(po3);

        }

        sprite.tagList.placeObject3(po3);

        return po3;

    }

    protected PlaceObject rect(RectNode node)

    {

        // Note that we will apply node.x and node.y as a translation operation

        // in the PlaceObject3 Matrix and instead start the shape from the

        // origin (0.0, 0.0).

        GraphicContext context = node.createGraphicContext();

        List<ShapeRecord> shapeRecords;

        if (node.radiusX != 0.0 || node.radiusY != 0.0

            || !Double.isNaN(node.topLeftRadiusX) || !Double.isNaN(node.topLeftRadiusY)

            || !Double.isNaN(node.topRightRadiusX) || !Double.isNaN(node.topRightRadiusY)

            || !Double.isNaN(node.bottomLeftRadiusX) || !Double.isNaN(node.bottomLeftRadiusY)

            || !Double.isNaN(node.bottomRightRadiusX) || !Double.isNaN(node.bottomRightRadiusY))

        {

             shapeRecords  = ShapeHelper.rectangle(0.0, 0.0, node.width, node.height,

                 node.radiusX, node.radiusY, node.topLeftRadiusX, node.topLeftRadiusY,

                 node.topRightRadiusX, node.topRightRadiusY, node.bottomLeftRadiusX, node.bottomLeftRadiusY,

                 node.bottomRightRadiusX, node.bottomRightRadiusY);

        }

        else

        {

             shapeRecords = ShapeHelper.rectangle(0.0, 0.0, node.width, node.height);

        }

       

        PlaceObject po3 = placeDefineShape(node, shapeRecords, node.fill, node.stroke, context);

        return po3;

    }

    protected PlaceObject text(TextGraphicNode node)

    {

        // No operation - text is ignored in this implementation.

        return null;

    }

    protected PlaceObject richtext(RichTextNode node)

    {

        // No operation - richtext is ignored in this implementation.

        return null;

    }

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

    //

    // FXG Library Definitions

    //

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

    protected PlaceObject placeObjectInstance(PlaceObjectNode node)

    {

        String definitionName = node.getNodeName();

        if (definitions == null)

            definitions = new HashMap<String, DefineSprite>();

        DefineSprite definitionSprite = definitions.get(definitionName);

        if (definitionSprite == null)

        {

            definitionSprite = createDefineSprite("Definition");

            FXG2SWFTranscoder graphics = newInstance();

            graphics.setResourceResolver(resourceResolver);

            definitions.put(definitionName, definitionSprite);

            graphics.definitions = definitions;

            graphics.definition(node.definition, definitionSprite);

        }

        PlaceObject po3 = placeObject(definitionSprite, node.createGraphicContext());

        return po3;

    }

    protected void definition(DefinitionNode node, DefineSprite definitionSprite)

    {

        GroupDefinitionNode groupDefinition = node.groupDefinition;

       

        if (groupDefinition == null)

        {

          //Exception:Definitions must define a single Group child node.

            throw new FXGException(node.getStartLine(), node.getStartColumn(), "MissingGroupChildNode");

        }

        spriteStack.push(definitionSprite);

        if (groupDefinition.definesScaleGrid())

        {

            definitionSprite.scalingGrid = createDefineScalingGrid(groupDefinition.getScalingGrid());

            definitionSprite.scalingGrid.scalingTarget = definitionSprite;

        }

        graphicContentNodes(groupDefinition.children);

        spriteStack.pop();

    }

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

    //

    // SWF Tags and Types Helper Methods

    //

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

    protected DefineBits createDefineBits(FXGNode node, String source)

    {

        try

        {

            InputStream stream = resourceResolver.openStream(source);

            DefineBits imageTag = ImageHelper.createDefineBits(stream, ImageHelper.guessMimeType(source));

            return imageTag;

        }

        catch (IOException ioe)

        {

            // Exception:Error {0} occurred while embedding image {1}.

            throw new FXGException(node.getStartLine(), node.getStartColumn(), "ErrorEmbeddingImage", ioe.getMessage(), source);

        }

    }

    protected DefineScalingGrid createDefineScalingGrid(ScalingGrid grid)

    {

        DefineScalingGrid scalingGrid = new DefineScalingGrid();

        scalingGrid.rect = TypeHelper.rect(grid.scaleGridLeft, grid.scaleGridTop, grid.scaleGridRight, grid.scaleGridBottom);

        return scalingGrid;

    }

    protected DefineSprite createDefineSprite(String name)

    {

        DefineSprite sprite = new DefineSprite();

        sprite.tagList = new TagList();

        sprite.framecount = 1;

        if (name == null) name = "";

        sprite.name = name + random.nextInt();

        return sprite;

    }

    protected DefineShape createDefineShape(AbstractShapeNode node, List<ShapeRecord> shapeRecords, FillNode fill,

            StrokeNode stroke, FXGMatrix transform, Winding... windings)

    {

        // Calculate the bounds of the shape outline (without strokes) - edgeBounds

        Rect edgeBounds = (node == null) ? ShapeHelper.getBounds(shapeRecords, null, (AbstractStrokeNode)stroke) : node.getBounds(shapeRecords, null);

       

        Rect shapeBounds;

        ShapeWithStyle sws = new ShapeWithStyle();

        sws.shapeRecords = shapeRecords;

        int lineStyleIndex = stroke == null ? 0 : 1;

        int fillStyle0Index = fill == null ? 0 : 1;

        int fillStyle1Index = 0;

        if (windings.length > 0)

          ShapeHelper.setPathStyles(shapeRecords, lineStyleIndex, fillStyle0Index, fillStyle1Index);

        else

          ShapeHelper.setStyles(shapeRecords, lineStyleIndex, fillStyle0Index, fillStyle1Index);

        if (fill != null)

        {

            FillStyle fillStyle = createFillStyle(fill, edgeBounds);

            sws.fillstyles = new ArrayList<FillStyle>(1);

            sws.fillstyles.add(fillStyle);

        }

        if (stroke != null)

        {

          //find the shapeBounds with stroke

          LineStyle ls = createGenericLineStyle((AbstractStrokeNode)stroke);

            shapeBounds = (node == null) ? ShapeHelper.getBounds(shapeRecords, ls, (AbstractStrokeNode)stroke) : node.getBounds(shapeRecords, ls);         

            LineStyle lineStyle = createLineStyle(stroke, shapeBounds);

            sws.linestyles = new ArrayList<LineStyle>();

            sws.linestyles.add(lineStyle);           

        }

        else

        {

          shapeBounds = edgeBounds;

        }

        DefineShape defineShape4 = new DefineShape(Tag.stagDefineShape4);

        defineShape4.shapeWithStyle = sws;

        defineShape4.bounds = shapeBounds;

        defineShape4.edgeBounds = edgeBounds;

        if ((fill != null) &&( windings.length > 0))

        {

          Winding windingValue = windings[0];

            defineShape4.usesFillWindingRule = (windingValue == Winding.NON_ZERO);

        }

       

        return defineShape4;

    }

   

   

    protected PlaceObject placeDefineShape(AbstractShapeNode node, List<ShapeRecord> shapeRecords,

            FillNode fill, StrokeNode stroke, GraphicContext context, Winding... windings )

    {

        if (node != null && fill!= null && !node.isPartofClipMask && ImageHelper.isBitmapFillWithClip(fill))

        {

            /* Support of fillMode=clip/scale is complicated since SWF does not

             * support proper clipping of bitmaps. For fillMode=clip/scale, FXG defines

             * the area outside of the bitmap fill area to be transparent.

             * In SWF, the bitmap bleeds to fill the rest of the path/shape

             * if bitmap is specified to be a clipping bitmap.

             *

             * In order to get the effect that FXG wants with SWF tags, the

             * the path/shape is split into two ShapeRecords for a path

             * with a stroke & fill. A clipping mask is applied to the fill

             * but not the stroke.

             */

           

            BitmapFillNode fillNode = (BitmapFillNode) fill;

            // Calculate the bounds of the shape outline (without strokes)

            Rect edgeBounds = node.getBounds(shapeRecords, null);          

           

            String source = parseSource(fillNode.source);

            if (source == null)

            {

                // Exception: Missing source attribute in <BitmapGraphic> or <BitmapFill>.

                throw new FXGException(fill.getStartLine(), fill.getStartColumn(), "MissingSourceAttribute");

            }

            DefineBits imageTag = createDefineBits(fill, source);

            //process the filters later to avoid masking

            List<FilterNode> filters = null;

            if (context.filters != null)      

            {  

                filters = context.filters;

                context.filters = null;

                DefineSprite filterSprite = createDefineSprite("MaskFilter");

                spriteStack.push(filterSprite);

            }

            DefineSprite imageSprite = createDefineSprite("BitmapFill");

            spriteStack.push(imageSprite);

            // First, generate the clipping mask

            DefineSprite clipSprite = createDefineSprite("BitmapFill_Clip");

            spriteStack.push(clipSprite);

            List<ShapeRecord> clipRectRecords = ShapeHelper.rectangle(0.0, 0.0, imageTag.width, imageTag.height);

            DefineShape clipShape = createDefineShape(null, clipRectRecords, new SolidColorFillNode(), null, context.getTransform());

            FXGMatrix bitmapMatrix = TypeHelper.bitmapFillMatrix(fillNode, imageTag, edgeBounds);

            FXGMatrix clipMatrix = new FXGMatrix(bitmapMatrix.a, bitmapMatrix.b, bitmapMatrix.c, bitmapMatrix.d, 0, 0);

            clipMatrix.scale(1.0/SwfConstants.TWIPS_PER_PIXEL, 1.0/SwfConstants.TWIPS_PER_PIXEL);

            clipMatrix.translate(bitmapMatrix.tx, bitmapMatrix.ty);

            GraphicContext clipContext = new GraphicContext();

            clipContext.setTransform(clipMatrix);

            placeObject(clipShape, clipContext);

            spriteStack.pop();

           

            // Set the depth of the mask to that of the bitmap image fill

            clipContext.setTransform(context.getTransform());

            PlaceObject po3clip = placeObject(clipSprite, clipContext);

            po3clip.setClipDepth(po3clip.depth+1);

           

            // Then, process the bitmap image fill

            ShapeWithStyle sws = new ShapeWithStyle();

            sws.shapeRecords = shapeRecords;

            int lineStyleIndex = 0;

            int fillStyle0Index = 1;

            int fillStyle1Index = 0;

            if (windings.length > 0)

                ShapeHelper.setPathStyles(shapeRecords, lineStyleIndex, fillStyle0Index, fillStyle1Index);

            else

                ShapeHelper.setStyles(shapeRecords, lineStyleIndex, fillStyle0Index, fillStyle1Index);

            FillStyle fillStyle = createFillStyle(fill, edgeBounds);

            sws.fillstyles = new ArrayList<FillStyle>(1);

            sws.fillstyles.add(fillStyle);

           

            DefineShape imageShape = new DefineShape(Tag.stagDefineShape4);

            imageShape.shapeWithStyle = sws;

            imageShape.bounds = edgeBounds;

            imageShape.edgeBounds = edgeBounds;

            if ((fill != null) &&( windings.length > 0))

            {

                Winding windingValue = windings[0];

                imageShape.usesFillWindingRule = (windingValue == Winding.NON_ZERO);

            }

            PlaceObject po3 = placeObject(imageShape, context);       

            

            if (stroke != null)

            {

                //make a copy of ShapeRecord for strokes

                ArrayList<ShapeRecord> shapeRecords2 = new ArrayList<ShapeRecord>(shapeRecords);

                Collections.copy(shapeRecords2, shapeRecords);

                //generate the define sprite for the stroke object with no clipping

                ShapeWithStyle swsStroke = new ShapeWithStyle();

                swsStroke.shapeRecords = shapeRecords2;

   

                lineStyleIndex = 1;

                fillStyle0Index = 0;

                fillStyle1Index = 0;

                ShapeHelper.replaceStyles(shapeRecords2, lineStyleIndex, fillStyle0Index, fillStyle1Index);

                // Consider linestyle stroke widths with bounds calculation              

                AbstractStrokeNode strokeNode = (AbstractStrokeNode) stroke;

                LineStyle ls = createGenericLineStyle(strokeNode);

                Rect shapeBounds =  node.getBounds(shapeRecords2, ls);             

               

                LineStyle lineStyle = createLineStyle(stroke, shapeBounds);

                swsStroke.linestyles = new ArrayList<LineStyle>(1);

                swsStroke.linestyles.add(lineStyle);

                DefineShape strokeShape = new DefineShape(Tag.stagDefineShape4);

                strokeShape.shapeWithStyle = swsStroke;

                strokeShape.bounds = shapeBounds;

                strokeShape.edgeBounds = edgeBounds;

                po3 = placeObject(strokeShape, context);   

            }            

            spriteStack.pop();

            po3 = placeObject(imageSprite, new GraphicContext());

           

            // If filters were not processed, place the topmost sprite in display list and apply filters

            // This is done to force processing of masks before filters

            if (filters != null)

            {

                DefineSprite sprite = spriteStack.pop();   

                GraphicContext gc = new GraphicContext();

                gc.filters = filters;

                PlaceObject poFilter = placeObject(sprite, gc);

                return poFilter;           

            }

           

            return po3;

           

        }

        else

        {

          DefineShape shape = createDefineShape(node, shapeRecords, fill, stroke, context.getTransform(), windings);

          PlaceObject po3 = placeObject(shape, context);

          return po3;

        }

      

    }

   

    protected FillStyle createFillStyle(FillNode fill, Rect bounds)

     {

        if (fill instanceof SolidColorFillNode)

            return createFillStyle((SolidColorFillNode)fill);

        else if (fill instanceof LinearGradientFillNode)

            return createFillStyle((LinearGradientFillNode)fill, bounds);

        else if (fill instanceof RadialGradientFillNode)

            return createFillStyle((RadialGradientFillNode)fill, bounds);

        else if (fill instanceof BitmapFillNode)

            return createFillStyle((BitmapFillNode)fill, bounds);

        else

            return null;

    }

    protected FillStyle createFillStyle(SolidColorFillNode fill)

    {

        FillStyle fs = new FillStyle();

        fs.color = TypeHelper.colorARGB(fill.color, fill.alpha);

        fs.type = FillStyle.FILL_SOLID;

        return fs;

    }

    protected FillStyle createFillStyle(BitmapFillNode fill, Rect bounds)

    {       

        FillStyle fs = new FillStyle();

       

        if (ImageHelper.bitmapFillModeIsRepeat(fill))

            fs.type = FillStyle.FILL_BITS;

        else

            fs.type = FillStyle.FILL_BITS | FillStyle.FILL_BITS_CLIP;

        String sourceFormatted = parseSource(fill.source);

       

        if (sourceFormatted == null)

        {

            // Source is required after FXG 1.0

            // Exception: Missing source attribute in <BitmapGraphic> or <BitmapFill>.

            throw new FXGException(fill.getStartLine(), fill.getStartColumn(), "MissingSourceAttribute");

        }

        DefineBits img = createDefineBits(fill, sourceFormatted); 

        fs.bitmap = img;

       

        fs.matrix = TypeHelper.bitmapFillMatrix(fill, img, bounds).toSWFMatrix();

        return fs;

    }

    protected FillStyle createFillStyle(LinearGradientFillNode node, Rect bounds)

    {

        FillStyle fs = new FillStyle();

        fs.type = FillStyle.FILL_LINEAR_GRADIENT;

        fs.matrix = TypeHelper.linearGradientMatrix(node, bounds);

        Gradient gradient = new Gradient();

        populateGradient(gradient, node.entries, node.interpolationMethod, node.spreadMethod);

        fs.gradient = gradient;

        return fs;

    }

    protected FillStyle createFillStyle(LinearGradientStrokeNode node, Rect bounds)

    {

        FillStyle fs = new FillStyle();

        fs.type = FillStyle.FILL_LINEAR_GRADIENT;

        fs.matrix = TypeHelper.linearGradientMatrix(node, bounds);

        Gradient gradient = new Gradient();

        populateGradient(gradient, node.entries, node.interpolationMethod, node.spreadMethod);

        fs.gradient = gradient;

        return fs;

    }

    protected FillStyle createFillStyle(RadialGradientFillNode node, Rect bounds)

    {

        FillStyle fs = new FillStyle();

        fs.type = FillStyle.FILL_FOCAL_RADIAL_GRADIENT;

        fs.matrix = TypeHelper.radialGradientMatrix(node, bounds);

        FocalGradient gradient = new FocalGradient();

        populateGradient(gradient, node.entries, node.interpolationMethod, node.spreadMethod);

        gradient.focalPoint = (float)node.focalPointRatio;

        fs.gradient = gradient;

        return fs;

    }

    protected FillStyle createFillStyle(RadialGradientStrokeNode node, Rect bounds)

    {

        FillStyle fs = new FillStyle();

        fs.type = FillStyle.FILL_FOCAL_RADIAL_GRADIENT;

        fs.matrix = TypeHelper.radialGradientMatrix(node, bounds);

        FocalGradient gradient = new FocalGradient();

        populateGradient(gradient, node.entries, node.interpolationMethod, node.spreadMethod);

        gradient.focalPoint = (float)node.focalPointRatio;

        fs.gradient = gradient;

        return fs;

    }

   

    protected LineStyle createLineStyle(StrokeNode stroke, Rect bounds)

    {

        if (stroke instanceof SolidColorStrokeNode)

            return createLineStyle((SolidColorStrokeNode)stroke);

        else if (stroke instanceof LinearGradientStrokeNode)

            return createLineStyle((LinearGradientStrokeNode)stroke, bounds);

        else if (stroke instanceof RadialGradientStrokeNode)

            return createLineStyle((RadialGradientStrokeNode)stroke, bounds);

        else

            return null;

    }

    private LineStyle createGenericLineStyle(AbstractStrokeNode stroke)

    {

        LineStyle ls = new LineStyle();

        ls.width = (int)StrictMath.rint(stroke.getWeight() * SwfConstants.TWIPS_PER_PIXEL);

        int flags = 0;

        int startCapStyle = createCaps(stroke.caps);

        int endCapStyle = startCapStyle;

        int jointStyle = createJoints(stroke.joints);

        int noHorizonalScale = 1;

        int noVerticalScale = 1;

       

        // First set of 8 bit flags

        if (stroke.scaleMode == ScaleMode.VERTICAL || stroke.scaleMode == ScaleMode.NONE)

            flags |= noHorizonalScale << 1;

        if (stroke.scaleMode == ScaleMode.HORIZONTAL || stroke.scaleMode == ScaleMode.NONE)

            flags |= noVerticalScale << 2;

        flags |= jointStyle << 4;

        flags |= startCapStyle << 6;

        if (stroke.pixelHinting)

            flags |= 1;

        // Second set of 8 bit flags

        flags |= endCapStyle << 8;

        if (jointStyle == 2)

        {

            // Encoded in SWF as an 8.8 fixed point value

            ls.miterLimit = TypeHelper.fixed8(stroke.miterLimit);

        }

        ls.flags = flags;

        return ls;

    }

    protected LineStyle createLineStyle(SolidColorStrokeNode stroke)

    {

        LineStyle ls = createGenericLineStyle(stroke);

        ls.color = TypeHelper.colorARGB(stroke.color, stroke.alpha);

        return ls;

    }

   

    protected LineStyle createLineStyle(LinearGradientStrokeNode stroke, Rect bounds)

    {

        LineStyle ls = createGenericLineStyle(stroke);

        ls.fillStyle = createFillStyle(stroke, bounds);       

        int hasFillStyle = 1;

        ls.flags |= hasFillStyle << 3;

        return ls;

    }

    protected LineStyle createLineStyle(RadialGradientStrokeNode stroke, Rect edgeBounds)

    {

        LineStyle ls = createGenericLineStyle(stroke);

        ls.fillStyle = createFillStyle(stroke, edgeBounds);

        int hasFillStyle = 1;

        ls.flags |= hasFillStyle << 3;

        return ls;

    }

    protected int createCaps(Caps value)

    {

        if (value != null)

            return value.ordinal();

        else

            return Caps.NONE.ordinal();

    }

    protected int createJoints(Joints value)

    {

        if (value != null)

            return value.ordinal();

        else

            return Joints.ROUND.ordinal();

    }

    protected int createSpreadMode(SpreadMethod value)

    {

        return value.ordinal();

    }

    protected int createBlendMode(BlendMode value)

    {

        return value.ordinal();

    }

    protected int createInterpolationMode(InterpolationMethod value)

    {

        return value.ordinal();

    }

    protected List<Filter> createFilters(List<FilterNode> list)

    {

        List<Filter> filters = new ArrayList<Filter>(list.size());

        Iterator<FilterNode> iterator = list.iterator();

        while (iterator.hasNext())

        {

            FilterNode f = iterator.next();

            if (f instanceof BevelFilterNode)

            {

                BevelFilterNode node = (BevelFilterNode)f;

                BevelFilter filter = createBevelFilter(node);

                filters.add(filter);

            }

            else if (f instanceof BlurFilterNode)

            {

                BlurFilterNode node = (BlurFilterNode)f;

                BlurFilter filter = createBlurFilter(node);

                filters.add(filter);

            }

            else if (f instanceof ColorMatrixFilterNode)

            {

                ColorMatrixFilterNode node = (ColorMatrixFilterNode)f;

                ColorMatrixFilter filter = new ColorMatrixFilter();

                filter.values = node.matrix;

                filters.add(filter);

            }

            else if (f instanceof DropShadowFilterNode)

            {

                DropShadowFilterNode node = (DropShadowFilterNode)f;

                DropShadowFilter filter = createDropShadowFilter(node);

                filters.add(filter);

            }

            else if (f instanceof GlowFilterNode)

            {

                GlowFilterNode node = (GlowFilterNode)f;

                GlowFilter filter = createGlowFilter(node);

                filters.add(filter);

            }

            else if (f instanceof GradientBevelFilterNode)

            {

                GradientBevelFilterNode node = (GradientBevelFilterNode)f;

                GradientBevelFilter filter = createGradientBevelFilter(node);

                filters.add(filter);

            }

            else if (f instanceof GradientGlowFilterNode)

            {

                GradientGlowFilterNode node = (GradientGlowFilterNode)f;

                GradientGlowFilter filter = createGradientGlowFilter(node);

                filters.add(filter);

            }

        }

        return filters;

    }

    protected BevelFilter createBevelFilter(BevelFilterNode node)

    {

        BevelFilter filter = new BevelFilter();

        filter.angle = TypeHelper.fixed(node.angle*Math.PI/180.0);

        filter.blurX = TypeHelper.fixed(node.blurX);

        filter.blurY = TypeHelper.fixed(node.blurY);

        filter.distance = TypeHelper.fixed(node.distance);

        filter.strength = TypeHelper.fixed8(node.strength);

        filter.shadowColor = TypeHelper.colorARGB(node.shadowColor, node.shadowAlpha);

        filter.highlightColor = TypeHelper.colorARGB(node.highlightColor, node.highlightAlpha);

        filter.flags = node.quality;

        if (node.type == BevelType.FULL)

            filter.flags |= 1 << 4;

        filter.flags |= 1 << 5; // Always a composite source

        if (node.knockout)

            filter.flags |= 1 << 6;

        if (node.type == BevelType.INNER)

            filter.flags |= 1 << 7;

        return filter;

    }

    protected BlurFilter createBlurFilter(BlurFilterNode node)

    {

        BlurFilter filter = new BlurFilter();

        filter.blurX = TypeHelper.fixed(node.blurX);

        filter.blurY = TypeHelper.fixed(node.blurY);

        filter.passes = node.quality << 3;

        return filter;

    }

    protected DropShadowFilter createDropShadowFilter(DropShadowFilterNode node)

    {

        DropShadowFilter filter = new DropShadowFilter();

        filter.color = TypeHelper.colorARGB(node.color, node.alpha);

        filter.angle = TypeHelper.fixed(node.angle*Math.PI/180.0);

        filter.blurX = TypeHelper.fixed(node.blurX);

        filter.blurY = TypeHelper.fixed(node.blurY);

        filter.distance = TypeHelper.fixed(node.distance);

        filter.strength = TypeHelper.fixed8(node.strength);

        filter.flags = node.quality;

        if (!node.hideObject) // Set CompositeSource bit for non-hiddenObject

            filter.flags |= 1 << 5;

        if (node.knockout)

            filter.flags |= 1 << 6;

        if (node.inner)

            filter.flags |= 1 << 7;

        return filter;

    }

    protected GlowFilter createGlowFilter(GlowFilterNode node)

    {

        GlowFilter filter = new GlowFilter();

        filter.color = TypeHelper.colorARGB(node.color, node.alpha);

        filter.blurX = TypeHelper.fixed(node.blurX);

        filter.blurY = TypeHelper.fixed(node.blurY);

        filter.strength = TypeHelper.fixed8(node.strength);

        filter.flags = node.quality;

        filter.flags |= 1 << 5; // Always a composite source

        if (node.knockout)

            filter.flags |= 1 << 6;

        if (node.inner)

            filter.flags |= 1 << 7;

        return filter;

    }

    protected GradientBevelFilter createGradientBevelFilter(

            GradientBevelFilterNode node)

    {

        GradientBevelFilter filter = new GradientBevelFilter();

        if (node.entries != null)

        {

            byte count = (byte)node.entries.size();

            filter.numcolors = count;

            filter.gradientColors = new int[count];

            filter.gradientRatio = new int[count];

            GradRecord[] records = createGradRecords(node.entries);

            for (int i = 0; i < records.length; i++)

            {

                GradRecord record = records[i];

                filter.gradientColors[i] = record.color;

                filter.gradientRatio[i] = record.ratio;

            }

        }

        filter.angle = TypeHelper.fixed(node.angle*Math.PI/180.0);

        filter.blurX = TypeHelper.fixed(node.blurX);

        filter.blurY = TypeHelper.fixed(node.blurY);

        filter.distance = TypeHelper.fixed(node.distance);

        filter.strength = TypeHelper.fixed8(node.strength);

        filter.flags = node.quality; // Quality encoded with 4 bits

        if (node.type == BevelType.FULL)

            filter.flags |= 1 << 4;

        filter.flags |= 1 << 5; // Always a composite source