Merge from Trunk revisions 740276 - 741103.

Hooked in the new AFP resource level defaults into the IF-size of the image handlers.

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

build.xml

       <src path="${basedir}/test/java"/>
       <patternset refid="test-sources"/>
       <classpath>
-        <path refid="libs-build-classpath"/>
+        <path refid="libs-build-tools-classpath"/>
         <fileset dir="${build.dir}">
           <include name="fop.jar"/>
         </fileset>
       <test name="org.apache.fop.text.linebreak.LineBreakStatusTest" todir="${junit.reports.dir}"/>
     </junit>
   </target>
-  <target name="junit" depends="junit-userconfig, junit-basic, junit-transcoder, junit-text-linebreak, junit-layout, junit-fotree, junit-area-tree-xml-format, junit-intermediate-format" description="Runs all of FOP's JUnit tests" if="junit.present">
+  <target name="junit-reduced" depends="junit-userconfig, junit-basic, junit-transcoder, junit-text-linebreak, junit-fotree"/>
+  <target name="junit-full" depends="junit-reduced, junit-layout, junit-area-tree-xml-format, junit-intermediate-format"/>
+  <target name="junit" depends="junit-full" description="Runs all of FOP's JUnit tests" if="junit.present">
     <fail><condition><or><isset property="fop.junit.error"/><isset property="fop.junit.failure"/><not><isset property="hyphenation.present"/></not></or></condition>
 NOTE:
 **************************************************************************
 <!-- =================================================================== -->
 <!-- Special target for Gump                                             -->
 <!-- =================================================================== -->
-  <target name="gump" depends="all, javadocs"/>
+  <target name="gump" depends="junit-reduced"/>
 <!-- =================================================================== -->
 <!-- Clean targets                                                       -->
 <!-- =================================================================== -->

src/documentation/content/xdocs/trunk/output.xml

       <ul>
         <li><a href="http://en.wikipedia.org/wiki/Advanced_Function_Presentation">AFP (Advanced Function Presentation)</a></li>
         <li><a href="http://wiki.apache.org/xmlgraphics-fop/AFPResources">AFP Resources on the FOP WIKI</a></li>
+        <li><a href="http://wiki.apache.org/xmlgraphics-fop/AFPOutput">Technical notes on AFP output in FOP</a></li>
       </ul>
     </section>
     <section id="afp-limitations">
         </li>
       </ul>
     </section>
+    <section id="afp-compatibility">
+      <title>Deployment in older environments</title>
+      <p>
+        There are still a big number of older (or limited) MO:DCA/IPDS environments in production
+        out there. AFP has grown in functionality over time and not every environment supports the
+        latest features. We're trying to make AFP output work in as many environments as possible.
+        However, to make AFP output work on older environments it is recommended to set to
+        configuration to 1 bit per pixel (see below on how to do this). In this case, all images
+        are converted to bi-level images using IOCA function set 10 (FS10). If a higher number of
+        bits per pixel is configured, FOP has to switch to at least FS11 which may not work
+        everywhere.
+      </p>
+    </section>
     <section id="afp-configuration">
       <title>Configuration</title>
       <section id="afp-font-config">
 ]]></source>
       <note>Be careful when using this option not to overwrite existing resource files from previous rendering runs.</note>
       </section>
+      <section id="afp-resource-level-defaults">
+        <title>Resource Level Defaults</title>
+        <p>
+          By default, bitmap image objects (or page segments derived from them) are put in the
+          print-file-level resource group and GOCA graphics are inlined for compatibility with
+          the AFP Workbench tool.
+        </p>
+        <p>
+          It is possible to override these defaults, either per image (see the
+          <link href="#afp-foreign-attributes-resource">afp:resource-level</link>
+          extension attribute below) or by specifying different defaults in the configuration:
+        </p>
+        <source><![CDATA[
+<default-resource-levels goca="print-file" bitmap="inline"/>]]></source>
+        <p>
+          "goca" refers to GOCA graphics and "bitmap" refers to IOCA images. The possible values
+          for the attributes are "inline" and "print-file". In the future,
+          additional possibilities may be added.
+        </p>
+      </section>
     </section>
     <section id="afp-extensions">
       <title>Extensions</title>
 ]]></source>
         <p>The resource-level attribute where the resource object will reside in the AFP output datastream.
         The possible values for this are "inline", "print-file" and "external".
-        When no resource-level attribute is provided, resources are by default placed at "print-file" level.
-        When "external" is used a resource-group-file attribute must also be specified.</p>
+        When "external" is used a resource-group-file attribute must also be specified.
+        Please refer to the <link href="#afp-resource-level-defaults">Resource Level Defaults</link>
+        above to see what is used if the resource-level attribute is not specified.
+        </p>
         <p></p>
       </section>
     </section>

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

             AFPResourceManager resourceManager, AFPResourceInfo resourceInfo,
             FontInfo fontInfo) {
         super(textAsShapes);
-        this.paintingState = paintingState;
-        this.resourceManager = resourceManager;
-        this.resourceInfo = resourceInfo;
-        this.fontInfo = fontInfo;
+        setPaintingState(paintingState);
+        setResourceManager(resourceManager);
+        setResourceInfo(resourceInfo);
+        setFontInfo(fontInfo);
     }
 
     /**
      *
      * @param resourceManager the AFP resource manager
      */
-    public void setResourceManager(AFPResourceManager resourceManager) {
+    private void setResourceManager(AFPResourceManager resourceManager) {
         this.resourceManager = resourceManager;
     }
 
      *
      * @param resourceInfo the AFP resource info
      */
-    public void setResourceInfo(AFPResourceInfo resourceInfo) {
+    private void setResourceInfo(AFPResourceInfo resourceInfo) {
         this.resourceInfo = resourceInfo;
     }
 
+    /**
+     * Returns the GOCA graphics object
+     *
+     * @return the GOCA graphics object
+     */
+    public GraphicsObject getGraphicsObject() {
+        return this.graphicsObj;
+    }
+
+    /**
+     * Sets the GOCA graphics object
+     *
+     * @param obj the GOCA graphics object
+     */
+    public void setGraphicsObject(GraphicsObject obj) {
+        this.graphicsObj = obj;
+    }
+
+    /**
+     * Sets the AFP painting state
+     *
+     * @param paintingState the AFP painting state
+     */
+    private void setPaintingState(AFPPaintingState paintingState) {
+        this.paintingState = paintingState;
+    }
+
+    /**
+     * Returns the AFP painting state
+     *
+     * @return the AFP painting state
+     */
+    public AFPPaintingState getPaintingState() {
+        return this.paintingState;
+    }
+
+    /**
+     * Sets the FontInfo
+     *
+     * @param fontInfo the FontInfo
+     */
+    private void setFontInfo(FontInfo fontInfo) {
+        this.fontInfo = fontInfo;
+    }
+
+    /**
+     * Returns the FontInfo
+     *
+     * @return the FontInfo
+     */
+    public FontInfo getFontInfo() {
+        return this.fontInfo;
+    }
+
     /**
      * Sets the GraphicContext
      *
         this.customTextHandler = handler;
     }
 
-    /**
-     * Returns the GOCA graphics object
-     *
-     * @return the GOCA graphics object
-     */
-    public GraphicsObject getGraphicsObject() {
-        return this.graphicsObj;
-    }
-
-    /**
-     * Sets the GOCA graphics object
-     *
-     * @param obj the GOCA graphics object
-     */
-    public void setGraphicsObject(GraphicsObject obj) {
-        this.graphicsObj = obj;
-    }
-
-    /**
-     * Sets the AFP painting state
-     *
-     * @param paintingState the AFP painting state
-     */
-    public void setPaintingState(AFPPaintingState paintingState) {
-        this.paintingState = paintingState;
-    }
-
-    /**
-     * Returns the AFP painting state
-     *
-     * @return the AFP painting state
-     */
-    public AFPPaintingState getPaintingState() {
-        return this.paintingState;
-    }
-
-    /**
-     * Returns the FontInfo
-     *
-     * @return the FontInfo
-     */
-    public FontInfo getFontInfo() {
-        return this.fontInfo;
-    }
-
     /** {@inheritDoc} */
     public void drawRenderableImage(RenderableImage img, AffineTransform xform) {
         log.debug("drawRenderableImage() NYI: img=" + img + ", xform=" + xform);

src/java/org/apache/fop/afp/AFPResourceInfo.java

  * The level at which a resource is to reside in the AFP output
  */
 public class AFPResourceInfo {
-    private static final AFPResourceLevel DEFAULT_LEVEL
+
+    /** the general default resource level */
+    public static final AFPResourceLevel DEFAULT_LEVEL
         = new AFPResourceLevel(AFPResourceLevel.PRINT_FILE);
 
-    /** the uri of this resource */
+    /** the URI of this resource */
     private String uri = null;
 
     /**
     private boolean levelChanged = false;
 
     /**
-     * Sets the data object uri
+     * Sets the data object URI.
      *
-     * @param uri the data object uri
+     * @param uri the data object URI
      */
     public void setUri(String uri) {
         this.uri = uri;
     }
 
     /**
-     * Returns the uri of this data object
+     * Returns the URI of this data object.
      *
-     * @return the uri of this data object
+     * @return the URI of this data object
      */
     public String getUri() {
         return uri;

src/java/org/apache/fop/afp/AFPResourceLevelDefaults.java

+/*
+ * 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.afp;
+
+import java.util.Iterator;
+import java.util.Map;
+
+import org.apache.fop.afp.modca.ResourceObject;
+
+/**
+ * This class holds resource levels defaults for the various resource types.
+ */
+public class AFPResourceLevelDefaults {
+
+    private static final Map RESOURCE_TYPE_NAMES = new java.util.HashMap();
+
+    static {
+        //Map to be extended as need arises:
+        registerResourceTypeName("goca", ResourceObject.TYPE_GRAPHIC);
+        registerResourceTypeName("bitmap", ResourceObject.TYPE_IMAGE);
+    }
+
+    private static void registerResourceTypeName(String name, byte type) {
+        RESOURCE_TYPE_NAMES.put(name.toLowerCase(), new Byte(type));
+    }
+
+    private static byte getResourceType(String resourceTypeName) {
+        Byte result = (Byte)RESOURCE_TYPE_NAMES.get(resourceTypeName.toLowerCase());
+        if (result == null) {
+            throw new IllegalArgumentException("Unknown resource type name: " + resourceTypeName);
+        }
+        return result.byteValue();
+    }
+
+    private Map defaultResourceLevels = new java.util.HashMap();
+
+    /**
+     * Creates a new instance with default values.
+     */
+    public AFPResourceLevelDefaults() {
+        // level not explicitly set/changed so default to inline for GOCA graphic objects
+        // (due to a bug in the IBM AFP Workbench Viewer (2.04.01.07), hard copy works just fine)
+        setDefaultResourceLevel(ResourceObject.TYPE_GRAPHIC,
+                new AFPResourceLevel(AFPResourceLevel.INLINE));
+    }
+
+    /**
+     * Sets the default resource level for a particular resource type.
+     * @param type the resource type name
+     * @param level the resource level
+     */
+    public void setDefaultResourceLevel(String type, AFPResourceLevel level) {
+        setDefaultResourceLevel(getResourceType(type), level);
+    }
+
+    /**
+     * Sets the default resource level for a particular resource type.
+     * @param type the resource type ({@link ResourceObject}.TYPE_*)
+     * @param level the resource level
+     */
+    public void setDefaultResourceLevel(byte type, AFPResourceLevel level) {
+        this.defaultResourceLevels.put(new Byte(type), level);
+    }
+
+    /**
+     * Returns the default resource level for a particular resource type.
+     * @param type the resource type ({@link ResourceObject}.TYPE_*)
+     * @return the default resource level
+     */
+    public AFPResourceLevel getDefaultResourceLevel(byte type) {
+        AFPResourceLevel result = (AFPResourceLevel)this.defaultResourceLevels.get(new Byte(type));
+        if (result == null) {
+            result = AFPResourceInfo.DEFAULT_LEVEL;
+        }
+        return result;
+    }
+
+    /**
+     * Allows to merge the values from one instance into another. Values from the instance passed
+     * in as a parameter override values of this instance.
+     * @param other the other instance to get the defaults from
+     */
+    public void mergeFrom(AFPResourceLevelDefaults other) {
+        Iterator iter = other.defaultResourceLevels.entrySet().iterator();
+        while (iter.hasNext()) {
+            Map.Entry entry = (Map.Entry)iter.next();
+            Byte type = (Byte)entry.getKey();
+            AFPResourceLevel level = (AFPResourceLevel)entry.getValue();
+            this.defaultResourceLevels.put(type, level);
+        }
+    }
+
+}

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

 
     private Map pageSegmentMap = new java.util.HashMap();
 
+    private AFPResourceLevelDefaults resourceLevelDefaults = new AFPResourceLevelDefaults();
+
     /**
      * Main constructor
      */
         currentPage.createIncludePageSegment(pageSegmentName, x, y, createHardPageSegments);
     }
 
+    /**
+     * Sets resource level defaults. The existing defaults over merged with the ones passed in
+     * as parameter.
+     * @param defaults the new defaults
+     */
+    public void setResourceLevelDefaults(AFPResourceLevelDefaults defaults) {
+        this.resourceLevelDefaults.mergeFrom(defaults);
+    }
+
+    /**
+     * Returns the resource level defaults in use with this resource manager.
+     * @return the resource level defaults
+     */
+    public AFPResourceLevelDefaults getResourceLevelDefaults() {
+        return this.resourceLevelDefaults;
+    }
 }

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

 
 package org.apache.fop.render.afp;
 
+import org.apache.fop.afp.AFPResourceLevelDefaults;
+
 /**
  * Interface used to customize the AFP renderer or document handler.
  */
      */
     void setDefaultResourceGroupFilePath(String filePath);
 
+    /**
+     * Sets the resource level defaults. The object passed in provides information which resource
+     * level shall be used by default for various kinds of resources.
+     * @param defaults the resource level defaults
+     */
+    void setResourceLevelDefaults(AFPResourceLevelDefaults defaults);
+
 }

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

 import java.io.IOException;
 import java.util.Map;
 
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-
 import org.apache.fop.afp.AFPPaintingState;
+import org.apache.fop.afp.AFPResourceLevelDefaults;
 import org.apache.fop.afp.AFPResourceManager;
 import org.apache.fop.afp.AFPUnitConverter;
 import org.apache.fop.afp.DataStream;
 public class AFPDocumentHandler extends AbstractBinaryWritingIFDocumentHandler
             implements AFPCustomizable {
 
-    /** logging instance */
-    private static Log log = LogFactory.getLog(AFPDocumentHandler.class);
+    //** logging instance */
+    //private static Log log = LogFactory.getLog(AFPDocumentHandler.class);
 
     /** the resource manager */
     private AFPResourceManager resourceManager;
         resourceManager.setDefaultResourceGroupFilePath(filePath);
     }
 
+    /** {@inheritDoc} */
+    public void setResourceLevelDefaults(AFPResourceLevelDefaults defaults) {
+        resourceManager.setResourceLevelDefaults(defaults);
+    }
+
     /**
      * Returns the page segment name for a given URI if it actually represents a page segment.
      * Otherwise, it just returns null.

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

 import org.apache.fop.afp.AFPGraphicsObjectInfo;
 import org.apache.fop.afp.AFPPaintingState;
 import org.apache.fop.afp.AFPResourceInfo;
-import org.apache.fop.afp.AFPResourceLevel;
+import org.apache.fop.afp.AFPResourceManager;
+import org.apache.fop.afp.modca.ResourceObject;
 import org.apache.fop.render.ImageHandler;
 import org.apache.fop.render.ImageHandlerUtil;
 import org.apache.fop.render.RenderingContext;
             AFPGraphicsObjectInfo graphicsObjectInfo
                 = (AFPGraphicsObjectInfo)super.generateDataObjectInfo(rendererImageInfo);
 
-            setDefaultToInlineResourceLevel(graphicsObjectInfo);
+            setDefaultResourceLevel(graphicsObjectInfo, afpInfo.getResourceManager());
 
             // set mime type (unsupported by MOD:CA registry)
             graphicsObjectInfo.setMimeType(MimeConstants.MIME_AFP_GOCA);
         }
     }
 
-    private void setDefaultToInlineResourceLevel(AFPGraphicsObjectInfo graphicsObjectInfo) {
+    private void setDefaultResourceLevel(AFPGraphicsObjectInfo graphicsObjectInfo,
+            AFPResourceManager resourceManager) {
         AFPResourceInfo resourceInfo = graphicsObjectInfo.getResourceInfo();
-        //level not explicitly set/changed so default to inline for GOCA graphic objects
-        // (due to a bug in the IBM AFP Workbench Viewer (2.04.01.07), hard copy works just fine)
         if (!resourceInfo.levelChanged()) {
-            resourceInfo.setLevel(new AFPResourceLevel(AFPResourceLevel.INLINE));
+            resourceInfo.setLevel(resourceManager.getResourceLevelDefaults()
+                    .getDefaultResourceLevel(ResourceObject.TYPE_GRAPHIC));
         }
     }
 
         graphicsObjectInfo.setObjectAreaInfo(
                 createObjectAreaInfo(afpContext.getPaintingState(), pos));
 
-        setDefaultToInlineResourceLevel(graphicsObjectInfo);
+        setDefaultResourceLevel(graphicsObjectInfo, afpContext.getResourceManager());
 
         // Image content
         ImageGraphics2D imageG2D = (ImageGraphics2D)image;

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

 import org.apache.fop.afp.AFPImageObjectInfo;
 import org.apache.fop.afp.AFPObjectAreaInfo;
 import org.apache.fop.afp.AFPPaintingState;
+import org.apache.fop.afp.AFPResourceInfo;
+import org.apache.fop.afp.AFPResourceManager;
+import org.apache.fop.afp.modca.ResourceObject;
 import org.apache.fop.render.ImageHandler;
 import org.apache.fop.render.RenderingContext;
 import org.apache.fop.util.bitmap.BitmapImageUtil;
         AFPRendererContext rendererContext
             = (AFPRendererContext)rendererImageInfo.getRendererContext();
         AFPInfo afpInfo = rendererContext.getInfo();
+
+        setDefaultResourceLevel(imageObjectInfo, afpInfo.getResourceManager());
+
         AFPPaintingState paintingState = afpInfo.getPaintingState();
         ImageRendered imageRendered = (ImageRendered) rendererImageInfo.img;
         Dimension targetSize = new Dimension(afpInfo.getWidth(), afpInfo.getHeight());
         return imageObjectInfo;
     }
 
+    private void setDefaultResourceLevel(AFPImageObjectInfo imageObjectInfo,
+            AFPResourceManager resourceManager) {
+        AFPResourceInfo resourceInfo = imageObjectInfo.getResourceInfo();
+        if (!resourceInfo.levelChanged()) {
+            resourceInfo.setLevel(resourceManager.getResourceLevelDefaults()
+                    .getDefaultResourceLevel(ResourceObject.TYPE_IMAGE));
+        }
+    }
+
     /** {@inheritDoc} */
     protected AFPDataObjectInfo createDataObjectInfo() {
         return new AFPImageObjectInfo();
         setResourceInformation(imageObjectInfo,
                 image.getInfo().getOriginalURI(),
                 afpContext.getForeignAttributes());
+        setDefaultResourceLevel(imageObjectInfo, afpContext.getResourceManager());
 
         // Positioning
         imageObjectInfo.setObjectAreaInfo(createObjectAreaInfo(afpContext.getPaintingState(), pos));

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

 import org.apache.fop.afp.AFPEventProducer;
 import org.apache.fop.afp.AFPPaintingState;
 import org.apache.fop.afp.AFPRectanglePainter;
+import org.apache.fop.afp.AFPResourceLevelDefaults;
 import org.apache.fop.afp.AFPResourceManager;
 import org.apache.fop.afp.AFPTextDataInfo;
 import org.apache.fop.afp.AFPUnitConverter;
         resourceManager.setDefaultResourceGroupFilePath(filePath);
     }
 
+    /** {@inheritDoc} */
+    public void setResourceLevelDefaults(AFPResourceLevelDefaults defaults) {
+        resourceManager.setResourceLevelDefaults(defaults);
+    }
+
     /** {@inheritDoc} */
     protected void establishTransformationMatrix(AffineTransform at) {
         saveGraphicsState();

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

 import org.apache.avalon.framework.configuration.Configuration;
 import org.apache.avalon.framework.configuration.ConfigurationException;
 
+import org.apache.fop.afp.AFPResourceLevel;
+import org.apache.fop.afp.AFPResourceLevelDefaults;
 import org.apache.fop.afp.fonts.AFPFontCollection;
 import org.apache.fop.afp.fonts.AFPFontInfo;
 import org.apache.fop.afp.fonts.CharacterSet;
                             + resourceGroupDest + "'");
             }
         }
+
+        Configuration defaultResourceLevelCfg = cfg.getChild("default-resource-levels", false);
+        if (defaultResourceLevelCfg != null) {
+            AFPResourceLevelDefaults defaults = new AFPResourceLevelDefaults();
+            String[] types = defaultResourceLevelCfg.getAttributeNames();
+            for (int i = 0, c = types.length; i < c; i++) {
+                String type = types[i];
+                try {
+                    String level = defaultResourceLevelCfg.getAttribute(type);
+                    defaults.setDefaultResourceLevel(type, AFPResourceLevel.valueOf(level));
+                } catch (IllegalArgumentException iae) {
+                    LogUtil.handleException(log, iae,
+                            userAgent.getFactory().validateUserConfigStrictly());
+                } catch (ConfigurationException e) {
+                    LogUtil.handleException(log, e,
+                            userAgent.getFactory().validateUserConfigStrictly());
+                }
+            }
+            customizable.setResourceLevelDefaults(defaults);
+        }
     }
 
     /** {@inheritDoc} */

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

 
 import org.apache.fop.afp.AFPPaintingState;
 import org.apache.fop.afp.AFPResourceInfo;
-import org.apache.fop.afp.AFPResourceLevel;
 import org.apache.fop.afp.AFPResourceManager;
+import org.apache.fop.afp.modca.ResourceObject;
 import org.apache.fop.render.AbstractRenderer;
 import org.apache.fop.render.ImageHandlerUtil;
 import org.apache.fop.render.RendererContext;
                 = new AFPForeignAttributeReader();
             AFPResourceInfo resourceInfo
                 = foreignAttributeReader.getResourceInfo(foreignAttributes);
-            // default to inline level if painted as GOCA
-            if (!resourceInfo.levelChanged() && !paintAsBitmap) {
-                resourceInfo.setLevel(new AFPResourceLevel(AFPResourceLevel.INLINE));
+            // set default resource level if an explicit one hasn't been set
+            if (!resourceInfo.levelChanged()) {
+                byte resourceType = paintAsBitmap
+                    ? ResourceObject.TYPE_IMAGE : ResourceObject.TYPE_GRAPHIC;
+                resourceInfo.setLevel(info.getResourceManager().getResourceLevelDefaults()
+                        .getDefaultResourceLevel(resourceType));
             }
             info.setResourceInfo(resourceInfo);
         }

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

 import org.apache.fop.afp.AFPDataObjectInfo;
 import org.apache.fop.afp.AFPObjectAreaInfo;
 import org.apache.fop.afp.AFPPaintingState;
+import org.apache.fop.afp.AFPResourceInfo;
+import org.apache.fop.afp.AFPResourceManager;
+import org.apache.fop.afp.modca.ResourceObject;
 import org.apache.fop.render.ImageHandler;
 import org.apache.fop.render.RenderingContext;
 
             AFPRendererImageInfo rendererImageInfo) throws IOException {
         AFPDataObjectInfo dataObjectInfo = super.generateDataObjectInfo(rendererImageInfo);
         ImageRawStream rawStream = (ImageRawStream) rendererImageInfo.getImage();
+        AFPRendererContext rendererContext
+            = (AFPRendererContext)rendererImageInfo.getRendererContext();
+        AFPInfo afpInfo = rendererContext.getInfo();
 
-
-        updateDataObjectInfo(dataObjectInfo, rawStream);
+        updateDataObjectInfo(dataObjectInfo, rawStream, afpInfo.getResourceManager());
 
         setAdditionalParameters(dataObjectInfo, rawStream);
         return dataObjectInfo;
     }
 
     private void updateDataObjectInfo(AFPDataObjectInfo dataObjectInfo,
-            ImageRawStream rawStream) throws IOException {
+            ImageRawStream rawStream, AFPResourceManager resourceManager) throws IOException {
         dataObjectInfo.setMimeType(rawStream.getFlavor().getMimeType());
+
+        AFPResourceInfo resourceInfo = dataObjectInfo.getResourceInfo();
+        if (!resourceInfo.levelChanged()) {
+            resourceInfo.setLevel(resourceManager.getResourceLevelDefaults()
+                    .getDefaultResourceLevel(ResourceObject.TYPE_IMAGE));
+        }
+
         InputStream inputStream = rawStream.createInputStream();
         try {
             dataObjectInfo.setData(IOUtils.toByteArray(inputStream));
 
         // Image content
         ImageRawStream imageStream = (ImageRawStream)image;
-        updateDataObjectInfo(dataObjectInfo, imageStream);
+        updateDataObjectInfo(dataObjectInfo, imageStream, afpContext.getResourceManager());
         setAdditionalParameters(dataObjectInfo, imageStream);
 
         // Create image

status.xml

       documents. Example: the fix of marks layering will be such a case when it's done.
     -->
     <release version="FOP Trunk" date="TBD">
+      <action context="Renderers" dev="JM" type="add">
+        AFP Output: Added a configuration option to override the resource level defaults in the
+        code.
+      </action>
       <action context="Code" dev="VH" type="fix" fixes-bug="46638">
         MinOptMaxUtil.toMinOptMax was converting LengthRangeProperty objects into illegal MinOptMax 
         objects (in some cases opt could be inferior to min).