* 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-ffa450edef68tags/fop-1_0
@@ -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(); | |||
} |
@@ -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( |
@@ -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; | |||
} | |||
} |
@@ -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; | |||
} | |||
} |
@@ -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(); |
@@ -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; | |||
} | |||
} |
@@ -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 | |||
+ "}"; |
@@ -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(); | |||
} | |||
} |
@@ -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(); | |||
} | |||
} |
@@ -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; | |||
// } | |||
} |
@@ -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(); | |||
} | |||
} |
@@ -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. | |||
* |
@@ -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 | |||
}; | |||
@@ -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); | |||
} |
@@ -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; | |||
} |
@@ -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 | |||
} | |||
} | |||
} |
@@ -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); | |||
} | |||
@@ -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; | |||
} |
@@ -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(); | |||
} | |||
} |
@@ -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)); | |||
} | |||
/** |
@@ -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; | |||
@@ -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); | |||
} | |||
} | |||
} |
@@ -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} | |||
* |
@@ -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} */ |
@@ -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]; |
@@ -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(); |
@@ -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; | |||
} | |||
} |
@@ -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( |
@@ -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; | |||
} | |||
} |
@@ -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; | |||
} | |||
} |