* Structural fixes with StrucFlgs class.

* IOCA image Registry additions.
* EPS support in ObjectContainer.

git-svn-id: https://svn.apache.org/repos/asf/xmlgraphics/fop/branches/Temp_AFPGOCAResources@691564 13f79535-47bb-0310-9956-ffa450edef68

src/java/org/apache/fop/render/afp/AFPAbstractImageFactory.java

@@ -0,0 +1,85 @@
+/*
+ * 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.
+ */
+
+/* $Id: $ */
+
+package org.apache.fop.render.afp;
+
+import java.io.IOException;
+
+/**
+ * Abstract image configurator
+ */
+public abstract class AFPAbstractImageFactory {
+    private static final int X = 0;
+    private static final int Y = 1;
+
+    /** the AFP state */
+    protected final AFPState state;
+
+    /** foreign attribute reader */
+    private final AFPForeignAttributeReader foreignAttributeReader
+        = new AFPForeignAttributeReader();
+
+    /**
+     * Main constructor
+     *
+     * @param state the AFP state
+     */
+    public AFPAbstractImageFactory(AFPState state) {
+        this.state = state;
+    }
+
+    /**
+     * Configures the data object info
+     *
+     * @param afpImageInfo the afp image info
+     * @return the data object info
+     * @throws IOException thrown if an I/O exception of some sort has occurred.
+     */
+    public AFPDataObjectInfo create(AFPImageInfo afpImageInfo) throws IOException {
+        AFPDataObjectInfo dataObjectInfo = createDataObjectInfo();
+        dataObjectInfo.setUri(afpImageInfo.uri);
+
+        // set resource information
+        AFPResourceInfo resourceInfo
+        = foreignAttributeReader.getResourceInfo(afpImageInfo.foreignAttributes);
+        dataObjectInfo.setResourceInfo(resourceInfo);
+
+        // set object area
+        AFPObjectAreaInfo objectAreaInfo = new AFPObjectAreaInfo();
+        float srcX = afpImageInfo.origin.x + (float)afpImageInfo.pos.getX();
+        float srcY = afpImageInfo.origin.y + (float)afpImageInfo.pos.getY();
+        AFPUnitConverter unitConv = state.getUnitConverter();
+        int[] coords = unitConv.mpts2units(new float[] {srcX, srcY});
+        objectAreaInfo.setX(coords[X]);
+        objectAreaInfo.setY(coords[Y]);
+        int width = Math.round(unitConv.mpt2units((float)afpImageInfo.pos.getWidth()));
+        objectAreaInfo.setWidth(width);
+        int height = Math.round(unitConv.mpt2units((float)afpImageInfo.pos.getHeight()));
+        objectAreaInfo.setHeight(height);
+        dataObjectInfo.setObjectAreaInfo(objectAreaInfo);
+        return dataObjectInfo;
+    }
+
+    /**
+     * Creates the data object information object
+     *
+     * @return the data object information object
+     */
+    protected abstract AFPDataObjectInfo createDataObjectInfo();
+}

src/java/org/apache/fop/render/afp/AFPDataObjectFactory.java

@@ -27,13 +27,11 @@ import org.apache.fop.render.afp.modca.Factory;
 import org.apache.fop.render.afp.modca.GraphicsObject;
 import org.apache.fop.render.afp.modca.ImageObject;
 import org.apache.fop.render.afp.modca.IncludeObject;
-import org.apache.fop.render.afp.modca.MapDataResource;
 import org.apache.fop.render.afp.modca.ObjectContainer;
 import org.apache.fop.render.afp.modca.Overlay;
 import org.apache.fop.render.afp.modca.PageSegment;
 import org.apache.fop.render.afp.modca.Registry;
 import org.apache.fop.render.afp.modca.ResourceObject;
-import org.apache.fop.render.afp.modca.triplets.FullyQualifiedNameTriplet;
 import org.apache.fop.render.afp.modca.triplets.MappingOptionTriplet;
 import org.apache.fop.render.afp.modca.triplets.ObjectClassificationTriplet;
 import org.apache.xmlgraphics.image.codec.tiff.TIFFImage;
@@ -55,58 +53,64 @@ public class AFPDataObjectFactory {
     }
 
     /**
-     * Creates an IOCA ImageObject or an ObjectContainer as appropriate.
+     * Creates and configures an ObjectContainer.
      *
-     * @param imageObjectInfo the image object info
-     * @return a newly created image object
+     * @param dataObjectInfo the object container info
+     * @return a newly created Object Container
      */
-    public AbstractDataObject createImage(AFPImageObjectInfo imageObjectInfo) {
-        AbstractDataObject dataObj = null;
-        // A known object type so place in an object container
-        if (imageObjectInfo.isBuffered()) {
-            // IOCA bitmap image
-            ImageObject imageObj = factory.createImageObject();
-            if (imageObjectInfo.hasCompression()) {
-                int compression = imageObjectInfo.getCompression();
-                switch (compression) {
-                case TIFFImage.COMP_FAX_G3_1D:
-                    imageObj.setEncoding(ImageContent.COMPID_G3_MH);
-                    break;
-                case TIFFImage.COMP_FAX_G3_2D:
-                    imageObj.setEncoding(ImageContent.COMPID_G3_MR);
-                    break;
-                case TIFFImage.COMP_FAX_G4_2D:
-                    imageObj.setEncoding(ImageContent.COMPID_G3_MMR);
-                    break;
-                default:
-                    throw new IllegalStateException(
-                            "Invalid compression scheme: " + compression);
-                }
-            }
+    public ObjectContainer createObjectContainer(AFPDataObjectInfo dataObjectInfo) {
+        ObjectContainer objectContainer = factory.createObjectContainer();
 
-            if (imageObjectInfo.isColor()) {
-                imageObj.setIDESize((byte) 24);
-            } else {
-                imageObj.setIDESize((byte) imageObjectInfo.getBitsPerPixel());
-            }
-            imageObj.setData(imageObjectInfo.getData());
+        // set object classification
+        Registry.ObjectType objectType = dataObjectInfo.getObjectType();
+        AFPResourceInfo resourceInfo = dataObjectInfo.getResourceInfo();
+        AFPResourceLevel resourceLevel = resourceInfo.getLevel();
+        final boolean dataInContainer = true;
+        final boolean containerHasOEG = resourceLevel.isInline();
+        final boolean dataInOCD = true;
+        objectContainer.setObjectClassification(
+                ObjectClassificationTriplet.CLASS_TIME_INVARIANT_PAGINATED_PRESENTATION_OBJECT,
+                objectType, dataInContainer, containerHasOEG, dataInOCD);
+
+        objectContainer.setInputStream(dataObjectInfo.getInputStream());
+        return objectContainer;
+    }
 
-            dataObj = imageObj;
+    /**
+     * Creates and configures an IOCA Image Object.
+     *
+     * @param imageObjectInfo the image object info
+     * @return a newly created IOCA Image Object
+     */
+    public ImageObject createImage(AFPImageObjectInfo imageObjectInfo) {
+        // IOCA bitmap image
+        ImageObject imageObj = factory.createImageObject();
+        if (imageObjectInfo.hasCompression()) {
+            int compression = imageObjectInfo.getCompression();
+            switch (compression) {
+            case TIFFImage.COMP_FAX_G3_1D:
+                imageObj.setEncoding(ImageContent.COMPID_G3_MH);
+                break;
+            case TIFFImage.COMP_FAX_G3_2D:
+                imageObj.setEncoding(ImageContent.COMPID_G3_MR);
+                break;
+            case TIFFImage.COMP_FAX_G4_2D:
+                imageObj.setEncoding(ImageContent.COMPID_G3_MMR);
+                break;
+            default:
+                throw new IllegalStateException(
+                        "Invalid compression scheme: " + compression);
+            }
+        }
 
+        if (imageObjectInfo.isColor()) {
+            imageObj.setIDESize((byte) 24);
         } else {
-            ObjectContainer objectContainer = factory.createObjectContainer();
-
-            Registry.ObjectType objectType = imageObjectInfo.getObjectType();
-
-            objectContainer.setObjectClassification(
-                    ObjectClassificationTriplet.CLASS_TIME_INVARIANT_PAGINATED_PRESENTATION_OBJECT,
-                    objectType);
-
-            objectContainer.setInputStream(imageObjectInfo.getInputStream());
-
-            dataObj = objectContainer;
+            imageObj.setIDESize((byte) imageObjectInfo.getBitsPerPixel());
         }
-        return dataObj;
+        imageObj.setData(imageObjectInfo.getData());
+
+        return imageObj;
     }
 
     /**
@@ -139,14 +143,17 @@ public class AFPDataObjectFactory {
             includeObj.setObjectType(IncludeObject.TYPE_GRAPHIC);
         } else {
             includeObj.setObjectType(IncludeObject.TYPE_OTHER);
-        }
-
-        Registry.ObjectType objectType = dataObjectInfo.getObjectType();
-        if (objectType != null) {
-            includeObj.setObjectClassification(
-               // object scope not defined
-               ObjectClassificationTriplet.CLASS_TIME_VARIANT_PRESENTATION_OBJECT,
-               objectType);
+            Registry.ObjectType objectType = dataObjectInfo.getObjectType();
+            if (objectType != null) {
+                // set object classification
+                final boolean dataInContainer = true;
+                final boolean containerHasOEG = false; // environment parameters set in include
+                final boolean dataInOCD = true;
+                includeObj.setObjectClassification(
+                   // object scope not defined
+                   ObjectClassificationTriplet.CLASS_TIME_VARIANT_PRESENTATION_OBJECT,
+                   objectType, dataInContainer, containerHasOEG, dataInOCD);
+            }
         }
 
         AFPObjectAreaInfo objectAreaInfo = dataObjectInfo.getObjectAreaInfo();
@@ -194,18 +201,22 @@ public class AFPDataObjectFactory {
             AbstractDataObject dataObj = (AbstractDataObject)namedObj;
 
             // other type by default
-            byte fqnType = FullyQualifiedNameTriplet.TYPE_OTHER_OBJECT_DATA_REF;
+//            byte fqnType = FullyQualifiedNameTriplet.TYPE_OTHER_OBJECT_DATA_REF;
             if (namedObj instanceof ObjectContainer) {
                 resourceObj.setType(ResourceObject.TYPE_OBJECT_CONTAINER);
 
+                // set object classification
+                final boolean dataInContainer = true;
+                final boolean containerHasOEG = false; // must be included
+                final boolean dataInOCD = true;
                 // mandatory triplet for object container
                 resourceObj.setObjectClassification(
                     ObjectClassificationTriplet.CLASS_TIME_INVARIANT_PAGINATED_PRESENTATION_OBJECT,
-                    objectType);
+                    objectType, dataInContainer, containerHasOEG, dataInOCD);
             } else if (namedObj instanceof ImageObject) {
                 resourceObj.setType(ResourceObject.TYPE_IMAGE);
                 // ioca image type
-                fqnType = FullyQualifiedNameTriplet.TYPE_BEGIN_RESOURCE_OBJECT_REF;
+//                fqnType = FullyQualifiedNameTriplet.TYPE_BEGIN_RESOURCE_OBJECT_REF;
             } else if (namedObj instanceof GraphicsObject) {
                 resourceObj.setType(ResourceObject.TYPE_GRAPHIC);
             } else {
@@ -214,12 +225,12 @@ public class AFPDataObjectFactory {
             }
 
             // set the map data resource
-            MapDataResource mapDataResource = factory.createMapDataResource();
-            mapDataResource.setFullyQualifiedName(
-                 fqnType,
-                 FullyQualifiedNameTriplet.FORMAT_CHARSTR,
-                 resourceObj.getName());
-            dataObj.getObjectEnvironmentGroup().setMapDataResource(mapDataResource);
+//            MapDataResource mapDataResource = factory.createMapDataResource();
+//            mapDataResource.setFullyQualifiedName(
+//                 fqnType,
+//                 FullyQualifiedNameTriplet.FORMAT_CHARSTR,
+//                 resourceObj.getName());
+//            dataObj.getObjectEnvironmentGroup().setMapDataResource(mapDataResource);
 
         } else {
             throw new UnsupportedOperationException(

src/java/org/apache/fop/render/afp/AFPDataObjectInfo.java

@@ -19,6 +19,8 @@
 
 package org.apache.fop.render.afp;
 
+import java.io.InputStream;
+
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.fop.render.afp.modca.Registry;
@@ -26,7 +28,7 @@ import org.apache.fop.render.afp.modca.Registry;
 /**
  * A list of parameters associated with an AFP data objects
  */
-public abstract class AFPDataObjectInfo {
+public class AFPDataObjectInfo {
     private static final Log log = LogFactory.getLog("org.apache.fop.afp");
 
     /** the object area info */
@@ -41,12 +43,45 @@ public abstract class AFPDataObjectInfo {
     /** the data object height */
     private int dataHeight;
 
+    /** the object data in an inputstream */
+    private InputStream inputStream;
+
+    /** the object registry mimetype */
+    private String mimeType;
+
     /**
      * Default constructor
      */
     public AFPDataObjectInfo() {
     }
 
+    /**
+     * Sets the image mime type
+     *
+     * @param mimeType the image mime type
+     */
+    public void setMimeType(String mimeType) {
+        this.mimeType = mimeType;
+    }
+
+    /**
+     * Returns the mime type of this data object
+     *
+     * @return the mime type of this data object
+     */
+    public String getMimeType() {
+        return mimeType;
+    }
+
+    /**
+     * Convenience method to return the object type
+     *
+     * @return the object type
+     */
+    public Registry.ObjectType getObjectType() {
+        return Registry.getInstance().getObjectType(getMimeType());
+    }
+
     /**
      * Returns the resource level at which this data object should reside
      *
@@ -88,7 +123,8 @@ public abstract class AFPDataObjectInfo {
 
     /** {@inheritDoc} */
     public String toString() {
-        return "mimeType=" + getMimeType()
+        return "AFPDataObjectInfo{"
+            + "mimeType=" + mimeType
             + ", dataWidth=" + dataWidth
             + ", dataHeight=" + dataHeight
             + (objectAreaInfo != null ? ", objectAreaInfo=" + objectAreaInfo : "")
@@ -150,18 +186,21 @@ public abstract class AFPDataObjectInfo {
     }
 
     /**
-     * Returns the mime type of this data object
+     * Sets the object data inputstream
      *
-     * @return the mime type of this data object
+     * @param inputStream the object data inputstream
      */
-    public abstract String getMimeType();
+    public void setInputStream(InputStream inputStream) {
+        this.inputStream = inputStream;
+    }
 
     /**
-     * Convenience method to return the object type
+     * Returns the object data inputstream
      *
-     * @return the object type
+     * @return the object data inputstream
      */
-    public Registry.ObjectType getObjectType() {
-        return Registry.getInstance().getObjectType(getMimeType());
+    public InputStream getInputStream() {
+        return this.inputStream;
     }
+
 }

src/java/org/apache/fop/render/afp/AFPDataObjectInfoFactory.java

@@ -0,0 +1,81 @@
+/*
+ * 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.
+ */
+
+/* $Id: $ */
+
+package org.apache.fop.render.afp;
+
+import java.util.Iterator;
+import java.util.Map;
+
+import org.apache.xmlgraphics.image.loader.Image;
+import org.apache.xmlgraphics.image.loader.impl.ImageRawCCITTFax;
+import org.apache.xmlgraphics.image.loader.impl.ImageRawStream;
+import org.apache.xmlgraphics.image.loader.impl.ImageRendered;
+
+/**
+ * AFP image configurator
+ */
+public class AFPDataObjectInfoFactory {
+    private final Map dataObjectInfoFactoryMap = new java.util.HashMap();
+    private final AFPState state;
+
+    /**
+     * Main constructor
+     *
+     * @param state the AFP state
+     */
+    public AFPDataObjectInfoFactory(AFPState state) {
+        this.state = state;
+        init();
+    }
+
+    /**
+     * Initialises the configurators
+     */
+    private void init() {
+        dataObjectInfoFactoryMap.put(
+                ImageRendered.class, new AFPImageRenderedFactory(state));
+        dataObjectInfoFactoryMap.put(
+                ImageRawCCITTFax.class, new AFPRawCCITTFaxFactory(state));
+        dataObjectInfoFactoryMap.put(
+                ImageRawStream.class, new AFPImageRawStreamFactory(state));
+    };
+
+    /**
+     * Returns the configurator for a given image
+     *
+     * @param img the image
+     * @return the image configurator for the image
+     */
+    public AFPAbstractImageFactory getFactory(Image img) {
+        Class clazz = img.getClass();
+        AFPAbstractImageFactory configurator
+            = (AFPAbstractImageFactory)dataObjectInfoFactoryMap.get(clazz);
+        // not directly matched so try to map ancestor
+        if (configurator == null) {
+            Iterator it = dataObjectInfoFactoryMap.keySet().iterator();
+            while (it.hasNext()) {
+                Class imageClass = (Class)it.next();
+                if (imageClass.isInstance(img)) {
+                    return (AFPAbstractImageFactory)dataObjectInfoFactoryMap.get(imageClass);
+                }
+            }
+        }
+        return configurator;
+    }
+}

src/java/org/apache/fop/render/afp/AFPGraphics2D.java

@@ -47,6 +47,7 @@ import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;
 import org.apache.commons.io.output.ByteArrayOutputStream;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
+import org.apache.fop.apps.MimeConstants;
 import org.apache.fop.render.afp.goca.GraphicsSetLineType;
 import org.apache.fop.render.afp.modca.GraphicsObject;
 import org.apache.xmlgraphics.image.loader.ImageInfo;
@@ -424,6 +425,7 @@ public class AFPGraphics2D extends AbstractGraphics2D {
         ImageRendered imgRend = new ImageRendered(imageInfo, buf, null);
         RenderedImage ri = imgRend.getRenderedImage();
 
+
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         try {
             // Serialize image
@@ -438,10 +440,8 @@ public class AFPGraphics2D extends AbstractGraphics2D {
 
         // create image object parameters
         AFPImageObjectInfo imageObjectInfo = new AFPImageObjectInfo();
-        imageObjectInfo.setBuffered(true);
         if (imageInfo != null) {
             imageObjectInfo.setUri(imageInfo.getOriginalURI());
-            imageObjectInfo.setMimeType(imageInfo.getMimeType());
         }
 
         AFPObjectAreaInfo objectAreaInfo = new AFPObjectAreaInfo();
@@ -465,7 +465,11 @@ public class AFPGraphics2D extends AbstractGraphics2D {
         imageObjectInfo.setData(baos.toByteArray());
         imageObjectInfo.setDataHeight(ri.getHeight());
         imageObjectInfo.setDataWidth(ri.getWidth());
-        imageObjectInfo.setColor(state.isColorImages());
+        boolean colorImages = state.isColorImages();
+        imageObjectInfo.setColor(colorImages);
+        imageObjectInfo.setMimeType(colorImages
+                    ? MimeConstants.MIME_AFP_IOCA_FS45
+                            : MimeConstants.MIME_AFP_IOCA_FS10);
         imageObjectInfo.setBitsPerPixel(state.getBitsPerPixel());
 
         AFPResourceManager resourceManager = info.getAFPResourceManager();

src/java/org/apache/fop/render/afp/AFPImageInfo.java

@@ -0,0 +1,72 @@
+/*
+ * 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.
+ */
+
+/* $Id: $ */
+
+package org.apache.fop.render.afp;
+
+import java.awt.Point;
+import java.awt.geom.Rectangle2D;
+import java.util.Map;
+
+import org.apache.xmlgraphics.image.loader.Image;
+import org.apache.xmlgraphics.image.loader.ImageInfo;
+
+/**
+ * The AFP image information
+ */
+public class AFPImageInfo {
+
+    /** the image uri */
+    protected final String uri;
+
+    /** the current pos */
+    protected final Rectangle2D pos;
+
+    /** the origin */
+    protected final Point origin;
+
+    /** the foreign attributes */
+    protected final Map foreignAttributes;
+
+    /** the image info */
+    protected final ImageInfo info;
+
+    /** the image */
+    protected final Image img;
+
+    /**
+     * Main constructor
+     *
+     * @param uri the image uri
+     * @param pos the image content area
+     * @param origin the current position
+     * @param info the image info
+     * @param img the image
+     * @param foreignAttributes the foreign attributes
+     */
+    public AFPImageInfo(String uri, Rectangle2D pos, Point origin,
+            ImageInfo info, Image img, Map foreignAttributes) {
+        this.uri = uri;
+        this.pos = pos;
+        this.origin = origin;
+        this.info = info;
+        this.img = img;
+        this.foreignAttributes = foreignAttributes;
+    }
+
+}

src/java/org/apache/fop/render/afp/AFPImageObjectInfo.java

@@ -19,7 +19,6 @@
 
 package org.apache.fop.render.afp;
 
-import java.io.InputStream;
 
 /**
  * A list of parameters associated with an image
@@ -34,18 +33,9 @@ public class AFPImageObjectInfo extends AFPDataObjectInfo {
     /** compression type if any */
     private int compression = -1;
 
-    /** the image mimetype */
-    private String mimeType;
-
-    /** is this a buffered image? */
-    private boolean buffered;
-
     /** the object data in a byte array */
     private byte[] data;
 
-    /** the object data in an inputstream */
-    private InputStream inputStream;
-
     /**
      * Default constructor
      */
@@ -71,15 +61,6 @@ public class AFPImageObjectInfo extends AFPDataObjectInfo {
         this.color = color;
     }
 
-    /**
-     * Sets the image mime type
-     *
-     * @param mimeType the image mime type
-     */
-    public void setMimeType(String mimeType) {
-        this.mimeType = mimeType;
-    }
-
     /**
      * Returns the number of bits used per pixel
      *
@@ -125,29 +106,6 @@ public class AFPImageObjectInfo extends AFPDataObjectInfo {
         this.compression = compression;
     }
 
-    /** {@inheritDoc} */
-    public String getMimeType() {
-        return mimeType;
-    }
-
-    /**
-     * Sets whether or not this is info about a buffered image
-     *
-     * @param buffered true if this is info about a buffered image
-     */
-    public void setBuffered(boolean buffered) {
-        this.buffered = buffered;
-    }
-
-    /**
-     * Returns true if this image info is about a buffered image
-     *
-     * @return true if this image info is about a buffered image
-     */
-    public boolean isBuffered() {
-        return this.buffered;
-    }
-
     /**
      * Sets the object data
      *
@@ -166,30 +124,10 @@ public class AFPImageObjectInfo extends AFPDataObjectInfo {
         return this.data;
     }
 
-    /**
-     * Sets the object data inputstream
-     *
-     * @param inputStream the object data inputstream
-     */
-    public void setInputStream(InputStream inputStream) {
-        this.inputStream = inputStream;
-    }
-
-    /**
-     * Returns the object data inputstream
-     *
-     * @return the object data inputstream
-     */
-    public InputStream getInputStream() {
-        return this.inputStream;
-    }
-
     /** {@inheritDoc} */
     public String toString() {
         return "AFPImageObjectInfo{" + super.toString()
-            + ", mimeType=" + mimeType
-            + ", buffered=" + buffered
-            + ", compression=" + compression
+            + "compression=" + compression
             + ", color=" + color
             + ", bitsPerPixel=" + bitsPerPixel
             + "}";

src/java/org/apache/fop/render/afp/AFPImageRawStreamFactory.java

@@ -0,0 +1,70 @@
+/*
+ * 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.
+ */
+
+/* $Id: $ */
+
+package org.apache.fop.render.afp;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.apache.xmlgraphics.image.loader.impl.ImageRawStream;
+
+/**
+ * A raw stream image configurator
+ */
+public class AFPImageRawStreamFactory extends AFPAbstractImageFactory {
+
+    /**
+     * Main constructor
+     *
+     * @param state the AFP state
+     */
+    public AFPImageRawStreamFactory(AFPState state) {
+        super(state);
+    }
+
+    /** {@inheritDoc} */
+    public AFPDataObjectInfo create(AFPImageInfo afpImageInfo) throws IOException {
+        AFPDataObjectInfo dataObjectInfo = super.create(afpImageInfo);
+        String mimeType = afpImageInfo.info.getMimeType();
+        if (mimeType != null) {
+            dataObjectInfo.setMimeType(mimeType);
+        }
+        ImageRawStream rawStream = (ImageRawStream) afpImageInfo.img;
+        int resolution = state.getResolution();
+
+        AFPObjectAreaInfo objectAreaInfo = dataObjectInfo.getObjectAreaInfo();
+        objectAreaInfo.setWidthRes(resolution);
+        objectAreaInfo.setHeightRes(resolution);
+
+        InputStream inputStream = rawStream.createInputStream();
+        dataObjectInfo.setInputStream(inputStream);
+
+        int dataHeight = rawStream.getSize().getHeightPx();
+        dataObjectInfo.setDataHeight(dataHeight);
+
+        int dataWidth = rawStream.getSize().getWidthPx();
+        dataObjectInfo.setDataWidth(dataWidth);
+        return dataObjectInfo;
+    }
+
+    /** {@inheritDoc} */
+    protected AFPDataObjectInfo createDataObjectInfo() {
+        return new AFPDataObjectInfo();
+    }
+}

src/java/org/apache/fop/render/afp/AFPImageRenderedFactory.java

@@ -0,0 +1,79 @@
+/*
+ * 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.
+ */
+
+/* $Id: $ */
+
+package org.apache.fop.render.afp;
+
+import java.awt.image.RenderedImage;
+import java.io.IOException;
+
+import org.apache.commons.io.output.ByteArrayOutputStream;
+import org.apache.fop.apps.MimeConstants;
+import org.apache.xmlgraphics.image.loader.impl.ImageRendered;
+import org.apache.xmlgraphics.ps.ImageEncodingHelper;
+
+/**
+ * A buffered image configurator
+ */
+public class AFPImageRenderedFactory extends AFPAbstractImageFactory {
+
+    /**
+     * Main constructor
+     *
+     * @param state the AFP state
+     */
+    public AFPImageRenderedFactory(AFPState state) {
+        super(state);
+    }
+
+    /** {@inheritDoc} */
+    public AFPDataObjectInfo create(AFPImageInfo afpImageInfo) throws IOException {
+        AFPImageObjectInfo imageObjectInfo
+            = (AFPImageObjectInfo)super.create(afpImageInfo);
+
+        ImageRendered imageRendered = (ImageRendered) afpImageInfo.img;
+        RenderedImage renderedImage = imageRendered.getRenderedImage();
+
+        ByteArrayOutputStream baout = new ByteArrayOutputStream();
+        ImageEncodingHelper.encodeRenderedImageAsRGB(renderedImage, baout);
+
+        imageObjectInfo.setData(baout.toByteArray());
+
+        int resolution = state.getResolution();
+
+        AFPObjectAreaInfo objectAreaInfo = imageObjectInfo.getObjectAreaInfo();
+        objectAreaInfo.setWidthRes(resolution);
+        objectAreaInfo.setHeightRes(resolution);
+
+        imageObjectInfo.setDataHeight(renderedImage.getHeight());
+        imageObjectInfo.setDataWidth(renderedImage.getWidth());
+
+        boolean colorImages = state.isColorImages();
+        imageObjectInfo.setColor(colorImages);
+        imageObjectInfo.setMimeType(colorImages
+                ? MimeConstants.MIME_AFP_IOCA_FS45
+                        : MimeConstants.MIME_AFP_IOCA_FS10);
+
+        return imageObjectInfo;
+    }
+
+    /** {@inheritDoc} */
+    protected AFPDataObjectInfo createDataObjectInfo() {
+        return new AFPImageObjectInfo();
+    }
+}

src/java/org/apache/fop/render/afp/AFPObjectAreaInfo.java

@@ -31,8 +31,6 @@ public class AFPObjectAreaInfo {
     private int widthRes;
     private int heightRes;
     private int rotation = 0;
-    private int offsetX;
-    private int offsetY;
 
     /**
      * Sets the x position of the data object
@@ -171,20 +169,4 @@ public class AFPObjectAreaInfo {
         + ", rotation=" + rotation;
     }
 
-//    public int getOffsetX() {
-//        return offsetX;
-//    }
-//
-//    public int getOffsetY() {
-//        return offsetY;
-//    }
-//
-//    public void setOffsetX(int afpx) {
-//        this.offsetX = afpx;
-//    }
-//
-//    public void setOffsetY(int afpy) {
-//        this.offsetY = afpy;
-//    }
-
 }

src/java/org/apache/fop/render/afp/AFPRawCCITTFaxFactory.java

@@ -0,0 +1,63 @@
+/*
+ * 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.
+ */
+
+/* $Id: $ */
+
+package org.apache.fop.render.afp;
+
+import java.io.IOException;
+
+import org.apache.xmlgraphics.image.loader.impl.ImageRawCCITTFax;
+
+/**
+ * An CITT fax image configurator
+ */
+public class AFPRawCCITTFaxFactory extends AFPAbstractImageFactory {
+
+    /**
+     * Main constructor
+     *
+     * @param state the afp state
+     */
+    public AFPRawCCITTFaxFactory(AFPState state) {
+        super(state);
+    }
+
+    /** {@inheritDoc} */
+    public AFPDataObjectInfo create(AFPImageInfo afpImageInfo) throws IOException {
+        AFPImageObjectInfo imageObjectInfo = (AFPImageObjectInfo)super.create(afpImageInfo);
+
+        ImageRawCCITTFax ccitt = (ImageRawCCITTFax) afpImageInfo.img;
+        imageObjectInfo.setCompression(ccitt.getCompression());
+
+        AFPObjectAreaInfo objectAreaInfo = imageObjectInfo.getObjectAreaInfo();
+        int xresol = (int) (ccitt.getSize().getDpiHorizontal() * 10);
+        objectAreaInfo.setWidthRes(xresol);
+
+        int yresol = (int) (ccitt.getSize().getDpiVertical() * 10);
+        objectAreaInfo.setHeightRes(yresol);
+
+        imageObjectInfo.setInputStream(ccitt.createInputStream());
+
+        return imageObjectInfo;
+    }
+
+    /** {@inheritDoc} */
+    protected AFPDataObjectInfo createDataObjectInfo() {
+        return new AFPImageObjectInfo();
+    }
+}

src/java/org/apache/fop/render/afp/AFPRenderer.java

@@ -27,15 +27,12 @@ import java.awt.geom.Rectangle2D;
 import java.awt.image.RenderedImage;
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
-import org.apache.commons.io.IOUtils;
-import org.apache.commons.io.output.ByteArrayOutputStream;
 import org.apache.fop.apps.FOPException;
 import org.apache.fop.apps.FOUserAgent;
 import org.apache.fop.apps.MimeConstants;
@@ -70,9 +67,6 @@ import org.apache.xmlgraphics.image.loader.ImageInfo;
 import org.apache.xmlgraphics.image.loader.ImageManager;
 import org.apache.xmlgraphics.image.loader.ImageSessionContext;
 import org.apache.xmlgraphics.image.loader.impl.ImageGraphics2D;
-import org.apache.xmlgraphics.image.loader.impl.ImageRawCCITTFax;
-import org.apache.xmlgraphics.image.loader.impl.ImageRawStream;
-import org.apache.xmlgraphics.image.loader.impl.ImageRendered;
 import org.apache.xmlgraphics.image.loader.impl.ImageXMLDOM;
 import org.apache.xmlgraphics.image.loader.util.ImageUtil;
 import org.apache.xmlgraphics.ps.ImageEncodingHelper;
@@ -160,6 +154,10 @@ public class AFPRenderer extends AbstractPathOrientedRenderer {
     /** the afp datastream */
     private DataStream dataStream;
 
+    /** data object information factory */
+    private final AFPDataObjectInfoFactory dataObjectInfoFactory;
+
+
     /**
      * Constructor for AFPRenderer.
      */
@@ -167,6 +165,7 @@ public class AFPRenderer extends AbstractPathOrientedRenderer {
         super();
         this.resourceManager = new AFPResourceManager();
         this.state = new AFPState();
+        this.dataObjectInfoFactory = new AFPDataObjectInfoFactory(state);
         this.unitConv = state.getUnitConverter();
     }
 
@@ -378,9 +377,9 @@ public class AFPRenderer extends AbstractPathOrientedRenderer {
     }
 
     private static final ImageFlavor[] FLAVORS = new ImageFlavor[] {
-        ImageFlavor.RAW_JPEG, ImageFlavor.RAW_CCITTFAX, ImageFlavor.GRAPHICS2D,
-        ImageFlavor.BUFFERED_IMAGE, ImageFlavor.RENDERED_IMAGE,
-        ImageFlavor.XML_DOM, /*ImageFlavor.RAW_EPS*/ };
+        ImageFlavor.RAW_JPEG, ImageFlavor.RAW_CCITTFAX, ImageFlavor.RAW_EPS,
+        ImageFlavor.GRAPHICS2D, ImageFlavor.BUFFERED_IMAGE, ImageFlavor.RENDERED_IMAGE,
+        ImageFlavor.XML_DOM };
 
     /** {@inheritDoc} */
     public void drawImage(String uri, Rectangle2D pos, Map foreignAttributes) {
@@ -396,11 +395,8 @@ public class AFPRenderer extends AbstractPathOrientedRenderer {
         if (name != null) {
             dataStream.createIncludePageSegment(name, coords[X], coords[Y]);
         } else {
-            Point origin = new Point(currentIPPosition, currentBPPosition);
-
             ImageManager manager = userAgent.getFactory().getImageManager();
             ImageInfo info = null;
-            InputStream in = null;
             try {
                 ImageSessionContext sessionContext = userAgent
                         .getImageSessionContext();
@@ -411,10 +407,21 @@ public class AFPRenderer extends AbstractPathOrientedRenderer {
                 org.apache.xmlgraphics.image.loader.Image img = manager.getImage(
                         info, FLAVORS, hints, sessionContext);
 
-                if (img instanceof ImageRendered || img instanceof ImageRawStream) {
-                    AFPImageObjectInfo imageObjectInfo
-                        = getImageObjectInfo(uri, info, pos, origin, img);
-                    resourceManager.createObject(imageObjectInfo);
+                Point origin = new Point(currentIPPosition, currentBPPosition);
+                AFPAbstractImageFactory factory = dataObjectInfoFactory.getFactory(img);
+                if (factory != null) {
+                    AFPImageInfo afpImageInfo
+                    = new AFPImageInfo(uri, pos, origin, info, img, foreignAttributes);
+                    AFPDataObjectInfo dataObjectInfo = null;
+                    try {
+                        dataObjectInfo = factory.create(afpImageInfo);
+                    } catch (IOException ioe) {
+                        ResourceEventProducer eventProducer
+                            = ResourceEventProducer.Provider.get(userAgent.getEventBroadcaster());
+                        eventProducer.imageWritingError(this, ioe);
+                        throw ioe;
+                    }
+                    resourceManager.createObject(dataObjectInfo);
                 } else if (img instanceof ImageGraphics2D) { // ...and process the image
                     ImageGraphics2D imageG2D = (ImageGraphics2D) img;
                     RendererContext rendererContext = createRendererContext(
@@ -446,113 +453,10 @@ public class AFPRenderer extends AbstractPathOrientedRenderer {
                         .get(userAgent.getEventBroadcaster());
                 eventProducer.imageIOError(this, (info != null ? info.toString()
                         : uri), ioe, null);
-            } finally {
-                if (in != null) {
-                    IOUtils.closeQuietly(in);
-                }
             }
         }
     }
 
-    /**
-     * Gets the AFP image object information for a given image
-     *
-     * @param uri the image uri
-     * @param info the image info
-     * @param pos the image content area
-     * @param origin the current position
-     * @param img the image
-     * @return an image object info
-     * @throws IOException thrown if an I/O exception of some sort has occurred
-     */
-    private AFPImageObjectInfo getImageObjectInfo(String uri, ImageInfo info, Rectangle2D pos,
-            Point origin, org.apache.xmlgraphics.image.loader.Image img) throws IOException {
-        AFPImageObjectInfo imageObjectInfo = new AFPImageObjectInfo();
-        imageObjectInfo.setUri(uri);
-        imageObjectInfo.setColor(state.isColorImages());
-        imageObjectInfo.setBitsPerPixel(state.getBitsPerPixel());
-        imageObjectInfo.setMimeType(info.getMimeType());
-
-        AFPObjectAreaInfo objectAreaInfo = new AFPObjectAreaInfo();
-
-        float srcX = origin.x + (float)pos.getX();
-        float srcY = origin.y + (float)pos.getY();
-        int[] coords = unitConv.mpts2units(new float[] {srcX, srcY});
-        objectAreaInfo.setX(coords[X]);
-        objectAreaInfo.setY(coords[Y]);
-
-        int width = Math.round(unitConv.mpt2units((float)pos.getWidth()));
-        objectAreaInfo.setWidth(width);
-
-        int height = Math.round(unitConv.mpt2units((float)pos.getHeight()));
-        objectAreaInfo.setHeight(height);
-
-        String mimeType = info.getMimeType();
-        if (mimeType != null) {
-            imageObjectInfo.setMimeType(mimeType);
-        }
-        imageObjectInfo.setObjectAreaInfo(objectAreaInfo);
-
-        if (img instanceof ImageRendered) {
-            imageObjectInfo.setBuffered(true);
-
-            ImageRendered imageRendered = (ImageRendered) img;
-            RenderedImage renderedImage = imageRendered.getRenderedImage();
-
-            ByteArrayOutputStream baout = new ByteArrayOutputStream();
-            try {
-                // Serialize image
-                // TODO Eventually, this should be changed not to buffer as
-                // this
-                // increases the
-                // memory consumption (see PostScript output)
-                ImageEncodingHelper.encodeRenderedImageAsRGB(renderedImage, baout);
-            } catch (IOException ioe) {
-                ResourceEventProducer eventProducer = ResourceEventProducer.Provider
-                        .get(userAgent.getEventBroadcaster());
-                eventProducer.imageWritingError(this, ioe);
-                throw ioe;
-            }
-            imageObjectInfo.setData(baout.toByteArray());
-
-            int resolution = state.getResolution();
-            objectAreaInfo.setWidthRes(resolution);
-            objectAreaInfo.setHeightRes(resolution);
-
-            imageObjectInfo.setDataHeight(renderedImage.getHeight());
-            imageObjectInfo.setDataWidth(renderedImage.getWidth());
-        } else {
-            imageObjectInfo.setBuffered(false);
-
-            ImageRawStream rawStream = (ImageRawStream) img;
-            if (img instanceof ImageRawCCITTFax) {
-                ImageRawCCITTFax ccitt = (ImageRawCCITTFax) img;
-                imageObjectInfo.setCompression(ccitt.getCompression());
-
-                int xresol = (int) (rawStream.getSize().getDpiHorizontal() * 10);
-                objectAreaInfo.setWidthRes(xresol);
-
-                int yresol = (int) (rawStream.getSize().getDpiVertical() * 10);
-                objectAreaInfo.setHeightRes(yresol);
-            } else {
-                int resolution = state.getResolution();
-                objectAreaInfo.setWidthRes(resolution);
-                objectAreaInfo.setHeightRes(resolution);
-            }
-
-            InputStream inputStream = rawStream.createInputStream();
-            imageObjectInfo.setInputStream(inputStream);
-
-            int dataHeight = rawStream.getSize().getHeightPx();
-            imageObjectInfo.setDataHeight(dataHeight);
-
-            int dataWidth = rawStream.getSize().getWidthPx();
-            imageObjectInfo.setDataWidth(dataWidth);
-
-        }
-        return imageObjectInfo;
-    }
-
     /**
      * Writes a RenderedImage to an OutputStream as raw sRGB bitmaps.
      *

src/java/org/apache/fop/render/afp/AFPResourceLevel.java

@@ -50,8 +50,7 @@ public class AFPResourceLevel {
     private static final String NAME_EXTERNAL = "external";
 
     private static final String[] NAMES = new String[] {
-        NAME_INLINE, NAME_PAGE, NAME_PAGE_GROUP,
-        NAME_DOCUMENT, NAME_PRINT_FILE, NAME_EXTERNAL
+        NAME_INLINE, NAME_PAGE, NAME_PAGE_GROUP, NAME_DOCUMENT, NAME_PRINT_FILE, NAME_EXTERNAL
     };
 
 

src/java/org/apache/fop/render/afp/AFPResourceManager.java

@@ -29,7 +29,6 @@ import org.apache.fop.render.afp.modca.AbstractDataObject;
 import org.apache.fop.render.afp.modca.AbstractNamedAFPObject;
 import org.apache.fop.render.afp.modca.DataStream;
 import org.apache.fop.render.afp.modca.Factory;
-import org.apache.fop.render.afp.modca.ImageObject;
 import org.apache.fop.render.afp.modca.IncludeObject;
 import org.apache.fop.render.afp.modca.Registry;
 import org.apache.fop.render.afp.modca.ResourceGroup;
@@ -131,13 +130,20 @@ public class AFPResourceManager {
         String includeName = (String)includeNameMap.get(resourceInfo);
         if (includeName == null) {
 
+            boolean canInclude = false;
+            Registry.ObjectType objectType = null;
+
             // new resource so create
             if (dataObjectInfo instanceof AFPImageObjectInfo) {
-                namedObj = dataObjectFactory.createImage((AFPImageObjectInfo)dataObjectInfo);
+                AFPImageObjectInfo imageObjectInfo = (AFPImageObjectInfo)dataObjectInfo;
+                namedObj = dataObjectFactory.createImage(imageObjectInfo);
+                canInclude = true;
             } else if (dataObjectInfo instanceof AFPGraphicsObjectInfo) {
                 namedObj = dataObjectFactory.createGraphic((AFPGraphicsObjectInfo)dataObjectInfo);
             } else {
-                throw new IllegalArgumentException("Unknown data object type: " + dataObjectInfo);
+                namedObj = dataObjectFactory.createObjectContainer(dataObjectInfo);
+                objectType = dataObjectInfo.getObjectType();
+                canInclude = objectType != null && objectType.isIncludable();
             }
 
             // set data object viewport (i.e. position, rotation, dimension, resolution)
@@ -147,19 +153,12 @@ public class AFPResourceManager {
             }
 
             AFPResourceLevel resourceLevel = resourceInfo.getLevel();
-
-            Registry.ObjectType objectType = dataObjectInfo.getObjectType();
-
             ResourceGroup resourceGroup = streamer.getResourceGroup(resourceLevel);
-
-            boolean canInclude = (resourceGroup != null) && (namedObj instanceof ImageObject
-                    || objectType != null && objectType.isIncludable());
+            canInclude &= resourceGroup != null;
 
             if (canInclude) {
-
                 // if it is to reside within a resource group at print-file or external level
                 if (resourceLevel.isPrintFile() || resourceLevel.isExternal()) {
-
                     // wrap newly created data object in a resource object
                     namedObj = dataObjectFactory.createResource(namedObj, resourceInfo, objectType);
                 }

src/java/org/apache/fop/render/afp/AFPStreamer.java

@@ -35,7 +35,6 @@ import org.apache.fop.render.afp.modca.DataStream;
 import org.apache.fop.render.afp.modca.Factory;
 import org.apache.fop.render.afp.modca.ResourceGroup;
 import org.apache.fop.render.afp.modca.StreamedResourceGroup;
-import org.apache.fop.render.afp.Streamable;
 
 /**
  * Manages the streaming of the AFP output
@@ -148,6 +147,7 @@ public class AFPStreamer implements Streamable {
         } else {
             // resource group in afp document datastream
             resourceGroup = dataStream.getResourceGroup(level);
+
         }
         return resourceGroup;
     }

src/java/org/apache/fop/render/afp/modca/AbstractAFPObject.java

@@ -88,11 +88,13 @@ public abstract class AbstractAFPObject implements Streamable {
      */
     protected void writeObjects(Collection/*<AbstractAFPObject>*/ objects, OutputStream os)
         throws IOException {
-        if (objects != null) {
-            for (Iterator it = objects.iterator(); it.hasNext();) {
+        if (objects != null && objects.size() > 0) {
+            Iterator it = objects.iterator();
+            while (it.hasNext()) {
                 Object object = it.next();
                 if (object instanceof Streamable) {
                     ((Streamable)object).writeToStream(os);
+                    it.remove(); // once written, immediately remove the object
                 }
             }
         }

src/java/org/apache/fop/render/afp/modca/AbstractPageObject.java

@@ -59,8 +59,7 @@ public abstract class AbstractPageObject extends AbstractNamedAFPObject {
     protected List/*<TagLogicalElement>*/ tagLogicalElements = null;
 
     /** The list of the include page segments */
-    protected List/*<IncludePageSegment>*/ includePageSegments
-        = new java.util.ArrayList/*<IncludePageSegment>*/();
+    protected List/*<IncludePageSegment>*/ includePageSegments = null;
 
     /** The list of objects within this resource container */
     protected List/*<AbstractStructuredAFPObject>*/ objects = new java.util.ArrayList();
@@ -248,7 +247,19 @@ public abstract class AbstractPageObject extends AbstractNamedAFPObject {
      */
     public void createIncludePageSegment(String name, int x, int y) {
         IncludePageSegment ips = factory.createIncludePageSegment(name, x, y);
-        includePageSegments.add(ips);
+        getIncludePageSegments().add(ips);
+    }
+
+    /**
+     * Returns the include page segments list
+     *
+     * @return the include page segments list
+     */
+    private List getIncludePageSegments() {
+        if (this.includePageSegments == null) {
+            this.includePageSegments = new java.util.ArrayList/*<IncludePageSegment>*/();
+        }
+        return this.includePageSegments;
     }
 
     /**
@@ -321,11 +332,6 @@ public abstract class AbstractPageObject extends AbstractNamedAFPObject {
     /** {@inheritDoc} */
     protected void writeContent(OutputStream os) throws IOException {
         super.writeContent(os);
-        if (this instanceof PageObject || this instanceof Overlay) {
-            getActiveEnvironmentGroup().writeToStream(os);
-        }
-        writeObjects(this.includePageSegments, os);
-        writeObjects(this.tagLogicalElements, os);
         writeObjects(this.objects, os);
     }
 

src/java/org/apache/fop/render/afp/modca/AbstractResourceEnvironmentGroupContainer.java

@@ -71,7 +71,8 @@ public abstract class AbstractResourceEnvironmentGroupContainer
      *            the name of the media map
      */
     public void createInvokeMediumMap(String name) {
-        addObject(new InvokeMediumMap(name));
+        InvokeMediumMap invokeMediumMap = factory.createInvokeMediumMap(name);
+        addObject(invokeMediumMap);
     }
 
     /** {@inheritDoc} */
@@ -89,7 +90,7 @@ public abstract class AbstractResourceEnvironmentGroupContainer
      */
     protected ResourceEnvironmentGroup getResourceEnvironmentGroup() {
         if (resourceEnvironmentGroup == null) {
-            this.resourceEnvironmentGroup = new ResourceEnvironmentGroup();
+            this.resourceEnvironmentGroup = factory.createResourceEnvironmentGroup();
         }
         return this.resourceEnvironmentGroup;
     }

src/java/org/apache/fop/render/afp/modca/AbstractResourceGroupContainer.java

@@ -21,15 +21,23 @@ package org.apache.fop.render.afp.modca;
 
 import java.io.IOException;
 import java.io.OutputStream;
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.apache.fop.render.afp.Streamable;
 
 
 /**
  * An abstract container of resource objects
  */
-public abstract class AbstractResourceGroupContainer extends AbstractPageObject {
+public abstract class AbstractResourceGroupContainer extends AbstractPageObject
+implements Streamable {
+
+    /** The container started state */
+    protected boolean started = false;
 
     /** the resource group object */
-    private ResourceGroup resourceGroup = null;
+    protected ResourceGroup resourceGroup = null;
 
     /**
      * Default constructor
@@ -107,11 +115,52 @@ public abstract class AbstractResourceGroupContainer extends AbstractPageObject
         return resourceGroup;
     }
 
+//    /** {@inheritDoc} */
+//    protected void writeContent(OutputStream os) throws IOException {
+//        if (resourceGroup != null) {
+//            resourceGroup.writeToStream(os);
+//        }
+//        super.writeContent(os);
+//    }
+
     /** {@inheritDoc} */
-    protected void writeContent(OutputStream os) throws IOException {
-        if (resourceGroup != null) {
-            resourceGroup.writeToStream(os);
+    public void writeToStream(OutputStream os) throws IOException {
+        if (!started) {
+            writeStart(os);
+            started = true;
+        }
+
+        writeContent(os);
+
+        if (complete) {
+            writeEnd(os);
+        }
+    }
+
+    /** {@inheritDoc} */
+    protected void writeObjects(Collection/*<AbstractAFPObject>*/ objects, OutputStream os)
+    throws IOException {
+        if (objects != null && objects.size() > 0) {
+            Iterator it = objects.iterator();
+            while (it.hasNext()) {
+                AbstractAFPObject ao = (AbstractAFPObject)it.next();
+                if (canWrite(ao)) {
+                    ao.writeToStream(os);
+                    it.remove();
+                } else {
+                    break;
+                }
+            }
         }
-        super.writeContent(os);
+    }
+
+    /**
+     * Returns true if this object can be written
+     *
+     * @param obj an AFP object
+     * @return true if this object can be written
+     */
+    protected boolean canWrite(AbstractAFPObject obj) {
+        return obj instanceof AbstractPageObject && ((AbstractPageObject)obj).isComplete();
     }
 }

src/java/org/apache/fop/render/afp/modca/AbstractStructuredAFPObject.java

@@ -28,11 +28,11 @@ import java.util.Iterator;
 import java.util.List;
 
 import org.apache.commons.io.output.ByteArrayOutputStream;
+import org.apache.fop.render.afp.modca.Registry.ObjectType;
 import org.apache.fop.render.afp.modca.triplets.FullyQualifiedNameTriplet;
 import org.apache.fop.render.afp.modca.triplets.MeasurementUnitsTriplet;
 import org.apache.fop.render.afp.modca.triplets.ObjectAreaSizeTriplet;
 import org.apache.fop.render.afp.modca.triplets.ObjectClassificationTriplet;
-import org.apache.fop.render.afp.modca.triplets.StrucFlgs;
 import org.apache.fop.render.afp.modca.triplets.Triplet;
 import org.apache.fop.render.afp.tools.BinaryUtils;
 
@@ -222,22 +222,16 @@ public abstract class AbstractStructuredAFPObject extends AbstractAFPObject {
      * @param objectClass the classification of the object
      * @param objectType the MOD:CA registry object type entry for the given
      *        object/component type of the object
-     * @param strucFlgs information on the structure of the object and its container
+     * @param dataInContainer whether the data resides in the container
+     * @param containerHasOEG whether the container has an object environment group
+     * @param dataInOCD whether the data resides in a object container data structured field
      */
-    public void setObjectClassification(byte objectClass, Registry.ObjectType objectType,
-            StrucFlgs strucFlgs) {
-        addTriplet(new ObjectClassificationTriplet(objectClass, objectType, strucFlgs));
-    }
-
-    /**
-     * Sets the objects classification with the default structure flags
-     *
-     * @param objectClass the classification of the object
-     * @param objectType the MOD:CA registry object type entry for the given
-     *        object/component type of the object
-     */
-    public void setObjectClassification(byte objectClass, Registry.ObjectType objectType) {
-        setObjectClassification(objectClass, objectType, StrucFlgs.DEFAULT);
+    public void setObjectClassification(
+            byte objectClass, ObjectType objectType,
+            boolean dataInContainer, boolean containerHasOEG, boolean dataInOCD) {
+        addTriplet(
+                new ObjectClassificationTriplet(
+                        objectClass, objectType, dataInContainer, containerHasOEG, dataInOCD));
     }
 
     /**

src/java/org/apache/fop/render/afp/modca/DataStream.java

@@ -29,8 +29,8 @@ import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.fop.render.afp.AFPFontAttributes;
 import org.apache.fop.render.afp.AFPResourceLevel;
-import org.apache.fop.render.afp.LineDataInfo;
 import org.apache.fop.render.afp.AFPTextDataInfo;
+import org.apache.fop.render.afp.LineDataInfo;
 import org.apache.fop.render.afp.fonts.AFPFont;
 import org.apache.fop.render.afp.modca.triplets.FullyQualifiedNameTriplet;
 

src/java/org/apache/fop/render/afp/modca/Document.java

@@ -21,9 +21,6 @@ package org.apache.fop.render.afp.modca;
 
 import java.io.IOException;
 import java.io.OutputStream;
-import java.util.Iterator;
-
-import org.apache.fop.render.afp.Streamable;
 
 /**
  * The document is the highest level of the MO:DCA data-stream document
@@ -49,13 +46,7 @@ import org.apache.fop.render.afp.Streamable;
  * of the document to be presented.
  *
  */
-public final class Document extends AbstractResourceEnvironmentGroupContainer implements Streamable {
-
-    /** The document started state */
-    private boolean started = false;
-
-    /** The document completion state */
-    private boolean complete = false;
+public final class Document extends AbstractResourceEnvironmentGroupContainer {
 
     /**
      * Constructor for the document object.
@@ -104,27 +95,4 @@ public final class Document extends AbstractResourceEnvironmentGroupContainer im
         return this.name;
     }
 
-    /** {@inheritDoc} */
-    public void writeToStream(OutputStream os) throws IOException {
-        if (!started) {
-            writeStart(os);
-            started = true;
-        }
-
-        Iterator it = objects.iterator();
-        while (it.hasNext()) {
-            AbstractAFPObject ao = (AbstractAFPObject)it.next();
-            if (ao instanceof PageGroup && ((PageGroup)ao).isComplete()
-                    || ao instanceof PageObject && ((PageObject)ao).isComplete()) {
-                ao.writeToStream(os);
-                it.remove();
-            } else {
-                break;
-            }
-        }
-
-        if (complete) {
-            writeEnd(os);
-        }
-    }
 }

src/java/org/apache/fop/render/afp/modca/Factory.java

@@ -517,6 +517,27 @@ public class Factory {
         return presentationEnvironmentControl;
     }
 
+    /**
+     * Creates a new MO:DCA {@link InvokeMediumMap}
+     *
+     * @param name the object name
+     * @return a new {@link InvokeMediumMap}
+     */
+    public InvokeMediumMap createInvokeMediumMap(String name) {
+        InvokeMediumMap invokeMediumMap = new InvokeMediumMap(name);
+        return invokeMediumMap;
+    }
+
+    /**
+     * Creates a new MO:DCA {@link ResourceEnvironmentGroup}
+     *
+     * @return a new {@link ResourceEnvironmentGroup}
+     */
+    public ResourceEnvironmentGroup createResourceEnvironmentGroup() {
+        ResourceEnvironmentGroup resourceEnvironmentGroup = new ResourceEnvironmentGroup();
+        return resourceEnvironmentGroup;
+    }
+
     /**
      * Creates a new IOCA {@link ImageSegment}
      *

src/java/org/apache/fop/render/afp/modca/ObjectContainer.java

@@ -23,6 +23,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 
+import org.apache.commons.io.IOUtils;
 import org.apache.fop.render.afp.AFPDataObjectInfo;
 import org.apache.fop.render.afp.AFPObjectAreaInfo;
 import org.apache.fop.render.afp.AFPResourceInfo;
@@ -80,6 +81,7 @@ public class ObjectContainer extends AbstractDataObject {
         final int lengthOffset = 1;
 
         copyChunks(dataHeader, lengthOffset, MAX_DATA_LEN, inputStream, os);
+        IOUtils.closeQuietly(inputStream);
     }
 
     /** {@inheritDoc} */

src/java/org/apache/fop/render/afp/modca/Overlay.java

@@ -64,6 +64,18 @@ public class Overlay extends PageObject {
         os.write(data);
     }
 
+    /** {@inheritDoc} */
+    protected void writeContent(OutputStream os) throws IOException {
+        super.writeContent(os);
+
+        getActiveEnvironmentGroup().writeToStream(os);
+
+        writeObjects(includePageSegments, os);
+        writeObjects(tagLogicalElements, os);
+        writeObjects(objects, os);
+    }
+
+
     /** {@inheritDoc} */
     protected void writeEnd(OutputStream os) throws IOException {
         byte[] data = new byte[17];

src/java/org/apache/fop/render/afp/modca/PageGroup.java

@@ -21,7 +21,6 @@ package org.apache.fop.render.afp.modca;
 
 import java.io.IOException;
 import java.io.OutputStream;
-import java.util.Iterator;
 import java.util.List;
 
 /**
@@ -38,9 +37,6 @@ public class PageGroup extends AbstractResourceEnvironmentGroupContainer {
     /** The tag logical elements contained within this group */
     private List tagLogicalElements = null;
 
-    /** the page group started state */
-    private boolean started = false;
-
     /**
      * Constructor for the PageGroup.
      *
@@ -100,29 +96,6 @@ public class PageGroup extends AbstractResourceEnvironmentGroupContainer {
         os.write(data);
     }
 
-    /** {@inheritDoc} */
-    public void writeToStream(OutputStream os) throws IOException {
-        if (!started) {
-            writeStart(os);
-            started = true;
-        }
-
-        Iterator it = objects.iterator();
-        while (it.hasNext()) {
-            AbstractAFPObject ao = (AbstractAFPObject)it.next();
-            if (ao instanceof PageObject && ((PageObject)ao).isComplete()) {
-                ao.writeToStream(os);
-                it.remove();
-            } else {
-                break;
-            }
-        }
-
-        if (complete) {
-            writeEnd(os);
-        }
-    }
-
     /** {@inheritDoc} */
     public String toString() {
         return this.getName();

src/java/org/apache/fop/render/afp/modca/PageObject.java

@@ -178,6 +178,17 @@ public class PageObject extends AbstractResourceGroupContainer {
         os.write(data);
     }
 
+    /** {@inheritDoc} */
+    protected void writeContent(OutputStream os) throws IOException {
+        super.writeContent(os);
+
+        getActiveEnvironmentGroup().writeToStream(os);
+
+        writeObjects(includePageSegments, os);
+        writeObjects(tagLogicalElements, os);
+        writeObjects(objects, os);
+    }
+
     /** {@inheritDoc} */
     protected void writeEnd(OutputStream os) throws IOException {
         byte[] data = new byte[17];
@@ -199,4 +210,9 @@ public class PageObject extends AbstractResourceGroupContainer {
     public String toString() {
         return this.getName();
     }
+
+    /** {@inheritDoc} */
+    protected boolean canWrite(AbstractAFPObject ao) {
+        return true;
+    }
 }

src/java/org/apache/fop/render/afp/modca/Registry.java

@@ -28,6 +28,9 @@ import org.apache.xmlgraphics.util.MimeConstants;
  */
 public final class Registry {
     /** IOB supported object types */
+    private static final byte COMPID_IOCA_FS10 = 5;
+    private static final byte COMPID_IOCA_FS11 = 11;
+    private static final byte COMPID_IOCA_FS45 = 12;
     private static final byte COMPID_EPS = 13;
     private static final byte COMPID_TIFF = 14;
     private static final byte COMPID_GIF = 22;
@@ -68,6 +71,36 @@ public final class Registry {
      * Initializes the mimetype map
      */
     private void init() {
+        mimeObjectTypeMap.put(
+                MimeConstants.MIME_AFP_IOCA_FS10,
+                new ObjectType(
+                        COMPID_IOCA_FS10,
+                        new byte[] {0x06, 0x07, 0x2B, 0x12, 0x00, 0x04, 0x01, 0x01, 0x05},
+                        "IOCA FS10",
+                        true,
+                        MimeConstants.MIME_AFP_IOCA_FS10
+                )
+        );
+        mimeObjectTypeMap.put(
+                MimeConstants.MIME_AFP_IOCA_FS11,
+                new ObjectType(
+                        COMPID_IOCA_FS11,
+                        new byte[] {0x06, 0x07, 0x2B, 0x12, 0x00, 0x04, 0x01, 0x01, 0x11},
+                        "IOCA FS11",
+                        true,
+                        MimeConstants.MIME_AFP_IOCA_FS11
+                )
+        );
+        mimeObjectTypeMap.put(
+                MimeConstants.MIME_AFP_IOCA_FS45,
+                new ObjectType(
+                        COMPID_IOCA_FS45,
+                        new byte[] {0x06, 0x07, 0x2B, 0x12, 0x00, 0x04, 0x01, 0x01, 0x12},
+                        "IOCA FS45",
+                        true,
+                        MimeConstants.MIME_AFP_IOCA_FS45
+                )
+        );
         mimeObjectTypeMap.put(
                 MimeConstants.MIME_EPS,
                 new ObjectType(

src/java/org/apache/fop/render/afp/modca/triplets/ObjectClassificationTriplet.java

@@ -22,7 +22,7 @@ package org.apache.fop.render.afp.modca.triplets;
 import java.io.UnsupportedEncodingException;
 
 import org.apache.fop.render.afp.AFPConstants;
-import org.apache.fop.render.afp.modca.Registry;
+import org.apache.fop.render.afp.modca.Registry.ObjectType;
 import org.apache.fop.render.afp.tools.StringUtils;
 
 /**
@@ -67,17 +67,16 @@ public class ObjectClassificationTriplet extends Triplet {
     /**
      * Main constructor
      *
-     * @param objectClass
-     *             the object class type
-     * @param objectType
-     *             the object type registry entry
-     * @param strucFlgs
-     *             the structured flags pertaining to this object classification triplet
+     * @param objectClass the object class type
+     * @param objectType the object type registry entry
+     * @param dataInContainer whether the data resides in the container
+     * @param containerHasOEG whether the container has an object environment group
+     * @param dataInOCD whether the data resides in a object container data structured field
      */
-    public ObjectClassificationTriplet(byte objectClass, Registry.ObjectType objectType,
-            StrucFlgs strucFlgs) {
+    public ObjectClassificationTriplet(byte objectClass, ObjectType objectType,
+            boolean dataInContainer, boolean containerHasOEG, boolean dataInOCD) {
         // no object level or company name specified
-        this(objectClass, objectType, strucFlgs, null, null);
+        this(objectClass, objectType, dataInContainer, containerHasOEG, dataInOCD, null, null);
     }
 
 
@@ -88,19 +87,17 @@ public class ObjectClassificationTriplet extends Triplet {
     /**
      * Fully parameterized constructor
      *
-     * @param objectClass
-     *             the object class type
-     * @param objectType
-     *             the object type registry entry
-     * @param strucFlgs
-     *             the structured flags pertaining to this object classification triplet
-     * @param objLev
-     *             the release level or version number of the object type
-     * @param compName
-     *             the name of the company or organization that owns the object definition
+     * @param objectClass the object class type
+     * @param objectType the object type registry entry
+     * @param dataInContainer whether the data resides in the container
+     * @param containerHasOEG whether the container has an object environment group
+     * @param dataInOCD whether the data resides in a object container data structured field
+     * @param objLev the release level or version number of the object type
+     * @param compName the name of the company or organization that owns the object definition
      */
-    public ObjectClassificationTriplet(byte objectClass, Registry.ObjectType objectType,
-            StrucFlgs strucFlgs, String objLev, String compName) {
+    public ObjectClassificationTriplet(byte objectClass, ObjectType objectType,
+            boolean dataInContainer, boolean containerHasOEG, boolean dataInOCD,
+            String objLev, String compName) {
         super(OBJECT_CLASSIFICATION);
 
         if (objectType == null) {
@@ -112,9 +109,11 @@ public class ObjectClassificationTriplet extends Triplet {
         data[1] = objectClass; // ObjClass
         data[2] = 0x00; // reserved (must be zero)
         data[3] = 0x00; // reserved (must be zero)
+
         // StrucFlgs - Information on the structure of the object container
-        data[4] = strucFlgs.getValue();
-        data[5] = 0x00; // StrucFlgs
+        byte[] strucFlgs = getStrucFlgs(dataInContainer, containerHasOEG, dataInOCD);
+        data[4] = strucFlgs[0];
+        data[5] = strucFlgs[1];
 
         byte[] oid = objectType.getOID();
         // RegObjId - MOD:CA-registered ASN.1 OID for object type (8-23)
@@ -153,4 +152,37 @@ public class ObjectClassificationTriplet extends Triplet {
         super.setData(data);
     }
 
+    /**
+     * Returns the structured field flags
+     *
+     * @param dataInContainer true if the object data in carried in the object container
+     * @param containerHasOEG true if the object container has an object environment group
+     * @param dataInOCD true if the object container data carries the object data
+     *
+     * @return the byte value of this structure
+     */
+    public byte[] getStrucFlgs(boolean dataInContainer, boolean containerHasOEG,
+            boolean dataInOCD) {
+        byte[] strucFlgs = new byte[2];
+        // Object Container (BOC/EOC)
+        if (dataInContainer) {
+            strucFlgs[0] |= 3 << 6;
+        } else {
+            strucFlgs[0] |= 1 << 6;
+        }
+        // Object Environment Group (OEG)
+        if (containerHasOEG) {
+            strucFlgs[0] |= 3 << 4;
+        } else {
+            strucFlgs[0] |= 1 << 4;
+        }
+        // Object Container Data (OCD) structured fields
+        if (dataInOCD) {
+            strucFlgs[0] |= 3 << 2;
+        } else {
+            strucFlgs[0] |= 1 << 2;
+        }
+        strucFlgs[1] = 0x00;
+        return strucFlgs;
+    }
 }

src/java/org/apache/fop/render/afp/modca/triplets/StrucFlgs.java

@@ -1,103 +0,0 @@
-/*
- * 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.
- */
-
-/* $Id: $ */
-
-package org.apache.fop.render.afp.modca.triplets;
-
-/**
- * Used by ObjectClassificationTriplet to provide
- * information on the structure of the object and its container
- */
-public class StrucFlgs {
-
-    private static final int OBJECT_DATA_NOT_CARRIED_IN_OBJECT_CONTAINER = 1;
-    private static final int OBJECT_DATA_OBJECT_CONTAINER_STRUCTURE_UNKNOWN = 2;
-    private static final int OBJECT_DATA_CARRIED_IN_OBJECT_CONTAINER = 3;
-
-    private static final int OBJECT_CONTAINER_NOT_INCLUDE_OBJECT_ENVIRONMENT_GROUP = 4;
-    private static final int OBJECT_CONTAINER_OBJECT_ENVIRONMENT_GROUP_CONTAINMENT_UNKNOWN = 8;
-    private static final int OBJECT_CONTAINER_INCLUDES_OBJECT_ENVIRONMENT_GROUP = 12;
-
-    private static final int OBJECT_CONTAINER_DATA_NOT_CARRIED_IN_OBJECT_DATA = 16;
-    private static final int OBJECT_CONTAINER_DATA_OBJECT_DATA_CONTAINMENT_UNKNOWN = 32;
-    private static final int OBJECT_CONTAINER_DATA_CARRIES_OBJECT_DATA = 48;
-
-//    private static final int OBJECT_DATA_NOT_CARRIED_IN_OBJECT_CONTAINER = 48;
-//    private static final int OBJECT_DATA_OBJECT_CONTAINER_STRUCTURE_UNKNOWN = 32;
-//    private static final int OBJECT_DATA_CARRIED_IN_OBJECT_CONTAINER = 16;
-//
-//    private static final int OBJECT_CONTAINER_NOT_INCLUDE_OBJECT_ENVIRONMENT_GROUP = 12;
-//    private static final int OBJECT_CONTAINER_OBJECT_ENVIRONMENT_GROUP_CONTAINMENT_UNKNOWN = 8;
-//    private static final int OBJECT_CONTAINER_INCLUDES_OBJECT_ENVIRONMENT_GROUP = 4;
-//
-//    private static final int OBJECT_CONTAINER_DATA_NOT_CARRIED_IN_OBJECT_DATA = 3;
-//    private static final int OBJECT_CONTAINER_DATA_OBJECT_DATA_CONTAINMENT_UNKNOWN = 2;
-//    private static final int OBJECT_CONTAINER_DATA_CARRIES_OBJECT_DATA = 1;
-
-    /**
-     * the default structured flags setting
-     * - data is in container with no object environment group and data in object container data
-     */
-    public static final StrucFlgs DEFAULT = new StrucFlgs(true, false, true);
-
-
-    private int value = 0;
-
-    /**
-     * Main constructor
-     *
-     * @param dataInContainer true if the object data in carried in the object container
-     * @param containerHasOEG true if the object container has an object environment group
-     * @param dataInOCD true if the object container data carries the object data
-     */
-    public StrucFlgs(boolean dataInContainer, boolean containerHasOEG, boolean dataInOCD) {
-        if (dataInContainer) {
-            this.value += OBJECT_DATA_CARRIED_IN_OBJECT_CONTAINER;
-        } else {
-            this.value += OBJECT_DATA_NOT_CARRIED_IN_OBJECT_CONTAINER;
-        }
-        if (containerHasOEG) {
-            this.value += OBJECT_CONTAINER_INCLUDES_OBJECT_ENVIRONMENT_GROUP;
-        } else {
-            this.value += OBJECT_CONTAINER_NOT_INCLUDE_OBJECT_ENVIRONMENT_GROUP;
-        }
-        if (dataInOCD) {
-            this.value += OBJECT_CONTAINER_DATA_CARRIES_OBJECT_DATA;
-        } else {
-            this.value += OBJECT_CONTAINER_DATA_NOT_CARRIED_IN_OBJECT_DATA;
-        }
-    }
-
-    /**
-     * Default constructor
-     */
-    public StrucFlgs() {
-        this.value = OBJECT_DATA_OBJECT_CONTAINER_STRUCTURE_UNKNOWN
-            + OBJECT_CONTAINER_OBJECT_ENVIRONMENT_GROUP_CONTAINMENT_UNKNOWN
-            + OBJECT_CONTAINER_DATA_OBJECT_DATA_CONTAINMENT_UNKNOWN;
-    }
-
-    /**
-     * Returns the value of structure flags value
-     *
-     * @return the value of structure flags value
-     */
-    public byte getValue() {
-        return (byte)this.value;
-    }
-}