Cleaned up code generation to reduce Eclipse warnings.

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

3 files changed, 851 insertions, 501 deletions

diff --git a/src/codegen/enumgen.xsl b/src/codegen/enumgen.xsl
index cc70e234a..e21366c3b 100644
--- a/src/codegen/enumgen.xsl
+++ b/src/codegen/enumgen.xsl
@@ -62,43 +62,54 @@ Software Foundation, please see <http://www.apache.org/>.
 <xsl:template match="text()"/>
 
 <xsl:template match="property[not(@type='generic')]">
- <xsl:variable name="classname">
-  <xsl:choose>
-    <xsl:when test="class-name">
-      <xsl:value-of select="class-name"/>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:call-template name="makeClassName">
-        <xsl:with-param name="propstr" select="name"/>
-      </xsl:call-template>
-    </xsl:otherwise>
-  </xsl:choose>
+  <xsl:variable name="classname">
+    <xsl:choose>
+      <xsl:when test="class-name">
+        <xsl:value-of select="class-name"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:call-template name="makeClassName">
+          <xsl:with-param name="propstr" select="name"/>
+        </xsl:call-template>
+      </xsl:otherwise>
+    </xsl:choose>
   </xsl:variable>
-   <xsl:variable name="bEnum">
-  <xsl:call-template name="hasEnum"/>
-   </xsl:variable>
-   <xsl:variable name="bSubpropEnum">
-  <xsl:call-template name="hasSubpropEnum"/>
-   </xsl:variable>
-
-   <xsl:if test="$bEnum='true' or contains($bSubpropEnum, 'true')">
-<redirect:write select="concat($classname, '.java')">
-package org.apache.fop.fo.properties;
-
-<!-- Handle enumeration values -->
-    public interface <xsl:value-of select="$classname"/>
-    <xsl:if test="use-generic and $bEnum='true'">
-  extends  <xsl:value-of select="use-generic"/>.Enums
-    </xsl:if>{
-   <xsl:for-each select="enumeration/value">
-     public final static int <xsl:value-of select="@const"/> = Constants.<xsl:value-of select="@const"/>;
-</xsl:for-each>
-<xsl:if test="contains($bSubpropEnum, 'true')">
-    <xsl:call-template name="genSubpropEnum"/>
-</xsl:if>
-    }
-</redirect:write>
-   </xsl:if>
+  <xsl:variable name="bEnum">
+    <xsl:call-template name="hasEnum"/>
+  </xsl:variable>
+  <xsl:variable name="bSubpropEnum">
+    <xsl:call-template name="hasSubpropEnum"/>
+  </xsl:variable>
+
+  <xsl:if test="$bEnum='true' or contains($bSubpropEnum, 'true')">
+    <redirect:write select="concat($classname, '.java')">
+      <xsl:text>package org.apache.fop.fo.properties;
+</xsl:text>
+      <!-- Handle enumeration values -->
+      <xsl:text>
+    public interface </xsl:text>
+      <xsl:value-of select="$classname"/>
+      <xsl:if test="use-generic and $bEnum='true'">
+        <xsl:text> extends </xsl:text>
+        <xsl:value-of select="use-generic"/>
+        <xsl:text>.Enums</xsl:text>
+      </xsl:if>
+      <xsl:text> {</xsl:text>
+      <xsl:for-each select="enumeration/value">
+        <xsl:text>
+        int </xsl:text>
+        <xsl:value-of select="@const"/>
+        <xsl:text> = Constants.</xsl:text>
+        <xsl:value-of select="@const"/>
+        <xsl:text>;</xsl:text>
+      </xsl:for-each>
+      <xsl:if test="contains($bSubpropEnum, 'true')">
+        <xsl:call-template name="genSubpropEnum"/>
+      </xsl:if>
+      <xsl:text> }
+</xsl:text>
+    </redirect:write>
+  </xsl:if>
 </xsl:template>
 
 <xsl:template name="genSubpropEnum">
@@ -106,66 +117,92 @@ package org.apache.fop.fo.properties;
   <xsl:choose>
     <xsl:when test="$prop/compound/subproperty/enumeration">
       <xsl:for-each select="compound/subproperty[enumeration]">
-      public interface <xsl:value-of select="name"/> {
+        <xsl:text>
+    public interface </xsl:text>
+        <xsl:value-of select="name"/>
+        <xsl:text> {
+</xsl:text>
         <xsl:for-each select="enumeration/value">
-        public final static int <xsl:value-of select="@const"/> =  Constants.<xsl:value-of select="@const"/>;
+          <xsl:text>
+        int </xsl:text>
+          <xsl:value-of select="@const"/>
+          <xsl:text> = Constants.</xsl:text>
+          <xsl:value-of select="@const"/>
+          <xsl:text>;</xsl:text>
         </xsl:for-each>
-      }
+        <xsl:text>
+    }
+</xsl:text>
       </xsl:for-each>
     </xsl:when>
     <xsl:when test="$prop/use-generic">
       <xsl:call-template name="inhspenums">
-         <xsl:with-param name="prop" select="key('genericref', $prop/use-generic)"/>
+        <xsl:with-param name="prop" select="key('genericref', $prop/use-generic)"/>
       </xsl:call-template>
     </xsl:when>
     <xsl:when test="$prop/compound/subproperty/use-generic">
-  <!-- generate "interface <subprop> extends <gensubprop>.Enums" -->
-  <xsl:for-each select="$prop/compound/subproperty[use-generic]">
-    <xsl:variable name="bSpEnum">
-      <xsl:call-template name="hasEnum">
-        <xsl:with-param name="prop"
-       select="key('genericref', use-generic)"/>
-            </xsl:call-template>
-    </xsl:variable>
-    <xsl:if test="$bSpEnum='true'">
-    public interface  <xsl:value-of select="name"/> extends  <xsl:value-of select="use-generic"/>.Enums { }
-    </xsl:if>
-  </xsl:for-each>
+      <!-- generate "interface <subprop> extends <gensubprop>.Enums" -->
+      <xsl:for-each select="$prop/compound/subproperty[use-generic]">
+        <xsl:variable name="bSpEnum">
+          <xsl:call-template name="hasEnum">
+            <xsl:with-param name="prop"
+              select="key('genericref', use-generic)"/>
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:if test="$bSpEnum='true'">
+          <xsl:text>
+    public interface </xsl:text>
+          <xsl:value-of select="name"/>
+          <xsl:text> extends </xsl:text>
+          <xsl:value-of select="use-generic"/>
+          <xsl:text>.Enums { }
+</xsl:text>
+        </xsl:if>
+      </xsl:for-each>
     </xsl:when>
-    <xsl:otherwise>false</xsl:otherwise>
+    <xsl:otherwise>
+      <xsl:text>
+        false</xsl:text>
+    </xsl:otherwise>
   </xsl:choose>
 </xsl:template>
 
 <xsl:template name="inhspenums">
   <xsl:param name="prop"/>
-      <xsl:variable name="generic_name">
-  <xsl:choose>
-    <xsl:when test="$prop/class-name">
-      <xsl:value-of select="$prop/class-name"/>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:call-template name="makeClassName">
-        <xsl:with-param name="propstr" select="$prop/name"/>
-      </xsl:call-template>
-    </xsl:otherwise>
-  </xsl:choose>
-      </xsl:variable>
-  <!-- generate "interface <subprop> extends <genprop>.<subprop>" -->
-      <xsl:for-each select="$prop/compound/subproperty[enumeration]">
-      <xsl:variable name="spname">
+  <xsl:variable name="generic_name">
+    <xsl:choose>
+      <xsl:when test="$prop/class-name">
+        <xsl:value-of select="$prop/class-name"/>
+      </xsl:when>
+      <xsl:otherwise>
         <xsl:call-template name="makeClassName">
-          <xsl:with-param name="propstr" select="name"/>
+          <xsl:with-param name="propstr" select="$prop/name"/>
         </xsl:call-template>
-      </xsl:variable>
-      public interface <xsl:value-of select="$spname"/> extends <xsl:value-of select="$generic_name"/>.Enums.<xsl:value-of select="$spname"/> {
-      }
-      </xsl:for-each>
-
-    <xsl:if test="$prop/use-generic">
-      <xsl:call-template name="inhspenums">
-         <xsl:with-param name="prop" select="key('genericref', $prop/use-generic)"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:variable>
+  <!-- generate "interface <subprop> extends <genprop>.<subprop>" -->
+  <xsl:for-each select="$prop/compound/subproperty[enumeration]">
+    <xsl:variable name="spname">
+      <xsl:call-template name="makeClassName">
+        <xsl:with-param name="propstr" select="name"/>
       </xsl:call-template>
-    </xsl:if>
+    </xsl:variable>
+    <xsl:text>
+        public interface </xsl:text>
+    <xsl:value-of select="$spname"/>
+    <xsl:text> extends </xsl:text>
+    <xsl:value-of select="$generic_name"/>
+    <xsl:text>.Enums.</xsl:text>
+    <xsl:value-of select="$spname"/>
+    <xsl:text> { }</xsl:text>
+  </xsl:for-each>
+
+  <xsl:if test="$prop/use-generic">
+    <xsl:call-template name="inhspenums">
+      <xsl:with-param name="prop" select="key('genericref', $prop/use-generic)"/>
+    </xsl:call-template>
+  </xsl:if>
 </xsl:template>
 
 </xsl:stylesheet>
diff --git a/src/codegen/genconst.xsl b/src/codegen/genconst.xsl
index f45de83bc..518b3a418 100644
--- a/src/codegen/genconst.xsl
+++ b/src/codegen/genconst.xsl
@@ -56,17 +56,20 @@ Software Foundation, please see <http://www.apache.org/>.
 
 <xsl:template match="allprops">
 <xsl:variable name="constlist">
-    <xsl:for-each select="document(propfile)//enumeration/value">
+  <xsl:for-each select="document(propfile)//enumeration/value">
     <xsl:sort select="@const"/>
-    <xsl:value-of select="@const"/>:</xsl:for-each>
+  <xsl:value-of select="@const"/>:</xsl:for-each>
 </xsl:variable>
+<xsl:text>
 package org.apache.fop.fo.properties;
 
-public interface Constants {
-  <xsl:call-template name="sortconsts">
-     <xsl:with-param name="consts" select="$constlist"/>
-  </xsl:call-template>
+public interface Constants {</xsl:text>
+<xsl:call-template name="sortconsts">
+  <xsl:with-param name="consts" select="$constlist"/>
+</xsl:call-template>
+<xsl:text>
 }
+</xsl:text>
 </xsl:template>
 
 <xsl:template name="sortconsts">
@@ -75,21 +78,26 @@ public interface Constants {
 <xsl:param name="num" select="1"/>
 <xsl:variable name="cval" select="substring-before($consts,':')"/>
 <xsl:choose>
- <xsl:when test="$consts = ''"/>
- <xsl:when test="$cval = $prevconst">
-  <xsl:call-template name="sortconsts">
-     <xsl:with-param name="consts" select="substring-after($consts,concat($cval, ':'))"/>
-     <xsl:with-param name="num" select="$num"/>
-     <xsl:with-param name="prevconst" select="$cval"/>
-  </xsl:call-template>
- </xsl:when>
- <xsl:otherwise>
-        public final static int <xsl:value-of select="$cval"/> = <xsl:value-of select="$num"/>;
-  <xsl:call-template name="sortconsts">
-     <xsl:with-param name="consts" select="substring-after($consts,concat($cval, ':'))"/>
-     <xsl:with-param name="num" select="$num + 1"/>
-     <xsl:with-param name="prevconst" select="$cval"/>
-  </xsl:call-template>
+  <xsl:when test="$consts = ''"/>
+  <xsl:when test="$cval = $prevconst">
+    <xsl:call-template name="sortconsts">
+      <xsl:with-param name="consts" select="substring-after($consts,concat($cval, ':'))"/>
+      <xsl:with-param name="num" select="$num"/>
+      <xsl:with-param name="prevconst" select="$cval"/>
+    </xsl:call-template>
+  </xsl:when>
+  <xsl:otherwise>
+    <xsl:text>
+      int </xsl:text>
+    <xsl:value-of select="$cval"/>
+    <xsl:text> = </xsl:text>
+    <xsl:value-of select="$num"/>
+    <xsl:text>;</xsl:text>
+    <xsl:call-template name="sortconsts">
+      <xsl:with-param name="consts" select="substring-after($consts,concat($cval, ':'))"/>
+      <xsl:with-param name="num" select="$num + 1"/>
+      <xsl:with-param name="prevconst" select="$cval"/>
+    </xsl:call-template>
   </xsl:otherwise>
 </xsl:choose>
 </xsl:template>
diff --git a/src/codegen/properties.xsl b/src/codegen/properties.xsl
index 5193d0dd4..37a2a8710 100644
--- a/src/codegen/properties.xsl
+++ b/src/codegen/properties.xsl
@@ -65,61 +65,85 @@ Software Foundation, please see <http://www.apache.org/>.
 
 <!-- Content of element is code to calculate the base length -->
 <xsl:template match="percent-ok">
+  <xsl:text>
     /** Return object used to calculate base Length
      * for percent specifications.
      */
-    public PercentBase getPercentBase(final FObj fo, final PropertyList propertyList) {
-     <xsl:choose>
-       <xsl:when test="@base">
-  return new LengthBase(fo, propertyList, LengthBase.<xsl:value-of select="@base"/>);
-       </xsl:when>
-       <xsl:otherwise>
-  return (new LengthBase(fo, propertyList, LengthBase.CUSTOM_BASE ) {
+    public PercentBase getPercentBase(final FObj fo, final PropertyList propertyList) {</xsl:text>
+  <xsl:choose>
+    <xsl:when test="@base">
+      <xsl:text>
+        return new LengthBase(fo, propertyList, LengthBase.</xsl:text>
+        <xsl:value-of select="@base"/><xsl:text>);
+</xsl:text>
+     </xsl:when>
+     <xsl:otherwise>
+       <!-- I have no idea what's happening here.  Is this supposed to be
+            an anonymous class returning the actual base length?
+            -->
+       <xsl:text>
+        return new LengthBase(fo, propertyList, LengthBase.CUSTOM_BASE) {
      public int getBaseLength() {
-      return (<xsl:value-of select="."/>);
+      return (</xsl:text>
+         <xsl:value-of select="."/>
+         <xsl:text>);
           }
-  });
-      </xsl:otherwise>
-    </xsl:choose>
-    }
+  });</xsl:text>
+       </xsl:otherwise>
+     </xsl:choose>
+     <xsl:text>
+    }</xsl:text>
 </xsl:template>
 
 <!-- Look for "auto" length keyword -->
 <xsl:template match="auto-ok">
+  <xsl:text>
     protected boolean isAutoLengthAllowed() {
-      return true;
-    }
+        return true;
+    }</xsl:text>
 </xsl:template>
 
 <xsl:template match="enumeration">
-    public Property checkEnumValues(String value) {
+  <xsl:text>
+    public Property checkEnumValues(String value) {</xsl:text>
     <xsl:for-each select="value">
       <xsl:call-template name="enumvals">
-          <xsl:with-param name="specvals" select="concat(.,' ')"/>
+        <xsl:with-param name="specvals" select="concat(.,' ')"/>
       </xsl:call-template>
     </xsl:for-each>
-  return super.checkEnumValues(value);
-    }
+    <xsl:text>
+        return super.checkEnumValues(value);
+    }</xsl:text>
 </xsl:template>
 
 
 <!-- Look for keyword equivalents. Value is the new expression  -->
 <xsl:template match="keyword-equiv[1]">
+  <xsl:text>
     // Initialize hashtable of keywords
     static HashMap s_htKeywords;
     static {
-  s_htKeywords = new HashMap(<xsl:value-of select="count(../keyword-equiv)"/>);
+        s_htKeywords = new HashMap(</xsl:text>
+    <xsl:value-of select="count(../keyword-equiv)"/>
+    <xsl:text>);</xsl:text>
   <xsl:for-each select="../keyword-equiv">
-        s_htKeywords.put("<xsl:value-of select="@match"/>", "<xsl:value-of select="."/>");
-  </xsl:for-each>
+    <xsl:text>
+        s_htKeywords.put("</xsl:text>
+      <xsl:value-of select="@match"/>
+      <xsl:text>", "</xsl:text>
+      <xsl:value-of select="."/>
+      <xsl:text>");</xsl:text>
+    </xsl:for-each>
+    <xsl:text>
     }
+
     protected String checkValueKeywords(String keyword) {
-      String value = (String)s_htKeywords.get(keyword);
-      if (value == null) {
-  return super.checkValueKeywords(keyword);
-      }
-      else return value;
-    }
+        String value = (String)s_htKeywords.get(keyword);
+        if (value == null) {
+            return super.checkValueKeywords(keyword);
+        }
+        else return value;
+    }</xsl:text>
 </xsl:template>
 
 <xsl:template match="keyword-equiv[position()>1]"/>
@@ -131,70 +155,98 @@ Software Foundation, please see <http://www.apache.org/>.
       <xsl:when test="../compound">
         <xsl:call-template name="propclass">
           <xsl:with-param name="prop"
-    select="../compound/subproperty[@set-by-shorthand]"/>
+            select="../compound/subproperty[@set-by-shorthand]"/>
         </xsl:call-template>
       </xsl:when><xsl:otherwise>
-        <xsl:call-template name="propclass">
-          <xsl:with-param name="prop" select=".."/>
-        </xsl:call-template>
-      </xsl:otherwise>
-    </xsl:choose>
-  </xsl:variable>
+      <xsl:call-template name="propclass">
+        <xsl:with-param name="prop" select=".."/>
+      </xsl:call-template>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:variable>
+<xsl:text>
+
     // See if other value types are acceptable
-    protected Property convertPropertyDatatype(Property p,
-  PropertyList propertyList, FObj fo) {
-      <xsl:for-each select="../datatype-conversion">
-      {
-        <xsl:variable name="dtc">
-          <xsl:choose>
-      <xsl:when test="@vartype">
-         <xsl:value-of select="@vartype"/>
-      </xsl:when><xsl:otherwise>
+    protected Property convertPropertyDatatype(
+                  Property p, PropertyList propertyList, FObj fo) {</xsl:text>
+  <xsl:for-each select="../datatype-conversion">
+    <xsl:variable name="dtc">
+      <xsl:choose>
+        <xsl:when test="@vartype">
+          <xsl:value-of select="@vartype"/>
+        </xsl:when><xsl:otherwise>
         <xsl:value-of select="@from-type"/>
       </xsl:otherwise>
     </xsl:choose>
   </xsl:variable>
-  <xsl:value-of select="$dtc"/><xsl:text> </xsl:text> <xsl:value-of select="@varname"/> =
-    p.get<xsl:value-of select="@from-type"/>();
-  if (<xsl:value-of select="@varname"/> != null) {
-      return new <xsl:value-of select="$propclass"/>(
-        <xsl:value-of select='.'/>);
-        }
-      }
+  <xsl:text>
+        </xsl:text>
+  <xsl:value-of select="$dtc"/>
+  <xsl:text> </xsl:text>
+  <xsl:value-of select="@varname"/>
+  <xsl:text> = p.get</xsl:text>
+  <xsl:value-of select="@from-type"/>
+  <xsl:text>();
+        if (</xsl:text>
+      <xsl:value-of select="@varname"/>
+      <xsl:text> != null) {
+            return new </xsl:text>
+      <xsl:value-of select="$propclass"/><xsl:text>(
+                    </xsl:text>
+        <xsl:value-of select='normalize-space(.)'/><xsl:text>);
+        }</xsl:text>
       </xsl:for-each>
-      return super.convertPropertyDatatype(p, propertyList, fo);
-    }
+      <xsl:text>
+        return super.convertPropertyDatatype(p, propertyList, fo);
+    }</xsl:text>
 </xsl:template>
 
 <xsl:template match="datatype-conversion[position()>1]"/>
 
 <!-- generate getDefaultForXXX for property components -->
 <xsl:template match="default[@subproperty]" priority="2">
-      <xsl:variable name="spname">
-  <xsl:call-template name="makeClassName">
-    <xsl:with-param name="propstr" select="@subproperty"/>
-  </xsl:call-template>
-      </xsl:variable>
-    protected String getDefaultFor<xsl:value-of  select='$spname'/>() {
-  return "<xsl:value-of  select='.'/>";
-    }
+  <xsl:variable name="spname">
+    <xsl:call-template name="makeClassName">
+      <xsl:with-param name="propstr" select="@subproperty"/>
+    </xsl:call-template>
+  </xsl:variable>
+  <xsl:text>
+    protected String getDefaultFor</xsl:text>
+    <xsl:value-of  select='$spname'/>
+    <xsl:text>() {
+        return "</xsl:text>
+    <xsl:value-of  select='.'/>
+    <xsl:text>";
+    }</xsl:text>
 </xsl:template>
 
 <!-- generate default "make" method for non-compound properties -->
 <xsl:template match="default[not(../compound)]" priority="1">
   <xsl:if test='not(@contextdep = "true")'>
-    private Property m_defaultProp=null;
+    <xsl:text>
+    private Property m_defaultProp=null;</xsl:text>
   </xsl:if>
-    public Property make(PropertyList propertyList) throws FOPException {
-      <xsl:choose><xsl:when test='@contextdep="true"'>
-        return make(propertyList, "<xsl:value-of select='.'/>", propertyList.getParentFObj());
-  </xsl:when><xsl:otherwise>
+  <xsl:text>
+    public Property make(PropertyList propertyList) throws FOPException {</xsl:text>
+    <xsl:choose>
+      <xsl:when test='@contextdep="true"'>
+        <xsl:text>
+        return make(propertyList, "</xsl:text>
+          <xsl:value-of select='.'/>
+          <xsl:text>", propertyList.getParentFObj());</xsl:text>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:text>
         if (m_defaultProp == null) {
-            m_defaultProp=make(propertyList, "<xsl:value-of select='.'/>", propertyList.getParentFObj());
-  }
-        return m_defaultProp;
-  </xsl:otherwise></xsl:choose>
-    }
+            m_defaultProp=make(propertyList, "</xsl:text>
+            <xsl:value-of select='.'/>
+            <xsl:text>", propertyList.getParentFObj());
+        }
+        return m_defaultProp;</xsl:text>
+          </xsl:otherwise>
+        </xsl:choose>
+        <xsl:text>
+    }</xsl:text>
 </xsl:template>
 
 <xsl:template match="text()"/>
@@ -205,410 +257,654 @@ Software Foundation, please see <http://www.apache.org/>.
 <!-- Only if more explicit rules not matched (ref) -->
 <xsl:template match="property">
 
-<!-- Only create a specific class for those properties not based on
-     template (generic) property definitions or which extends a
-     generic definition.
- -->
-<xsl:if test='not(use-generic) or count(*)>2'>
-
-<xsl:variable name="eclassname">
-  <xsl:choose>
-    <xsl:when test="class-name">
-      <xsl:value-of select="class-name"/>
-    </xsl:when>
-    <xsl:otherwise>
-      <xsl:call-template name="makeClassName">
-        <xsl:with-param name="propstr" select="name"/>
-      </xsl:call-template>
-    </xsl:otherwise>
-  </xsl:choose>
-</xsl:variable>
-
-<xsl:variable name="classname">
-     <xsl:value-of select="$eclassname"/><xsl:if test="not(@type='generic')">Maker</xsl:if>
-</xsl:variable>
-
-<!-- The class of the Property object to be created -->
-<xsl:variable name="propclass">
-  <xsl:call-template name="propclass"/>
-</xsl:variable>
+  <!-- Only create a specific class for those properties not based on
+       template (generic) property definitions or which extends a
+       generic definition.
+       -->
+  <xsl:if test='not(use-generic) or count(*)>2'>
+    
+    <xsl:variable name="eclassname">
+      <xsl:choose>
+        <xsl:when test="class-name">
+          <xsl:value-of select="class-name"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="makeClassName">
+            <xsl:with-param name="propstr" select="name"/>
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
 
-<!-- The superclass for this PropertyMaker -->
-<xsl:variable name="superclass">
-  <xsl:choose>
-  <xsl:when test="use-generic[@ispropclass='true']">
-    <xsl:value-of select="use-generic"/><xsl:text>.Maker</xsl:text>
-  </xsl:when>
-  <xsl:when test="use-generic">
-    <xsl:value-of select="use-generic"/>
-  </xsl:when>
-  <xsl:otherwise>
-    <xsl:value-of select="datatype"/><xsl:text>Property.Maker</xsl:text>
-  </xsl:otherwise>
-  </xsl:choose>
-</xsl:variable>
+    <xsl:variable name="classname">
+      <xsl:value-of select="$eclassname"/>
+      <xsl:if test="not(@type='generic')">
+        <xsl:text>Maker</xsl:text>
+      </xsl:if>
+    </xsl:variable>
 
-<!-- Is this property an Enum or derived from a generic Enum -->
-<xsl:variable name="enumconst">
-  <xsl:if test="enumeration/value and not(@type='generic')">
-  <xsl:text> implements </xsl:text><xsl:value-of select="$eclassname"/></xsl:if>
-</xsl:variable>
+    <!-- The class of the Property object to be created -->
+    <xsl:variable name="propclass">
+      <xsl:call-template name="propclass"/>
+    </xsl:variable>
 
-<redirect:write select="concat($classname, '.java')">
-package org.apache.fop.fo.properties;
-
-import java.util.HashMap;
-import org.apache.fop.datatypes.*;
-import org.apache.fop.fo.*;
-import org.apache.fop.apps.FOPException;
-
-public class <xsl:value-of select="$classname"/> extends  <xsl:value-of select="$superclass"/><xsl:value-of select="$enumconst"/> {
-
-<!-- If has enumerated values and is a generic class, create a nested
-  interface defining the enumeration constants -->
-<xsl:if test=".//enumeration and @type='generic'">
-  public interface Enums {
-<xsl:for-each select="enumeration/value">
-    int <xsl:value-of select="@const"/> =  Constants.<xsl:value-of select="@const"/>;
-</xsl:for-each>
-<xsl:for-each select="compound/subproperty[enumeration]">
-       <xsl:variable name="spname">
-  <xsl:call-template name="makeClassName">
-          <xsl:with-param name="propstr" select="name"/>
-        </xsl:call-template>
-      </xsl:variable>
-  public interface <xsl:value-of select="$spname"/> {
-<xsl:for-each select="enumeration/value">
-    int <xsl:value-of select="@const"/> =  Constants.<xsl:value-of select="@const"/>;
-</xsl:for-each>
-  }
-</xsl:for-each>
-  }
-</xsl:if>
+    <!-- The superclass for this PropertyMaker -->
+    <xsl:variable name="superclass">
+      <xsl:choose>
+        <xsl:when test="use-generic[@ispropclass='true']">
+          <xsl:value-of select="use-generic"/><xsl:text>.Maker</xsl:text>
+        </xsl:when>
+        <xsl:when test="use-generic">
+          <xsl:value-of select="use-generic"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="datatype"/><xsl:text>Property.Maker</xsl:text>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+
+    <!-- Is this property an Enum or derived from a generic Enum -->
+    <xsl:variable name="enumconst">
+      <xsl:if test="enumeration/value and not(@type='generic')">
+        <xsl:text> implements </xsl:text><xsl:value-of select="$eclassname"/></xsl:if>
+    </xsl:variable>
+
+    <redirect:write select="concat($classname, '.java')">
+      <xsl:text>package org.apache.fop.fo.properties;
+</xsl:text>
+      <xsl:if test=".//keyword-equiv or ./name[.='generic-color']">
+        <xsl:text>
+import java.util.HashMap;</xsl:text>
+      </xsl:if>
+      <xsl:if test=
+          "((./datatype and
+              (not (./datatype[.='String' or .='Enum' or .='List'
+                      or .='Length' or .='Character' or .='Number'])
+                    or (./datatype[.='Length'] and ./percent-ok)
+            ) )
+            or .//datatype-conversion)
+            and ./name[. !='generic-color']">
+        <xsl:text>
+import org.apache.fop.datatypes.*;</xsl:text>
+      </xsl:if>
+      <xsl:text>
+import org.apache.fop.fo.*;</xsl:text>
+      <xsl:if test="not(
+                    (./datatype and ./datatype[. ='List'])
+                    or ./class-name[.='GenericCondPadding']
+                    or ./name[.='generic-boolean'
+                              or .='generic-color'])">
+        <xsl:text>
+import org.apache.fop.apps.FOPException;</xsl:text>
+      </xsl:if>
+      <xsl:text>
+
+public class </xsl:text>
+      <xsl:value-of select="$classname"/>
+      <xsl:text> extends </xsl:text>
+      <xsl:value-of select="$superclass"/><xsl:value-of select="$enumconst"/>
+      <xsl:text> {</xsl:text>
+
+      <!-- If has enumerated values and is a generic class, create a nested
+           interface defining the enumeration constants -->
+      <xsl:if test=".//enumeration and @type='generic'">
+        <xsl:text>
+    public interface Enums {</xsl:text>
+        <xsl:for-each select="enumeration/value">
+          <xsl:text>
+        int </xsl:text>
+          <xsl:value-of select="@const"/>
+          <xsl:text> =  Constants.</xsl:text>
+          <xsl:value-of select="@const"/>
+          <xsl:text>;</xsl:text>
+        </xsl:for-each>
+        <xsl:for-each select="compound/subproperty[enumeration]">
+          <xsl:variable name="spname">
+            <xsl:call-template name="makeClassName">
+              <xsl:with-param name="propstr" select="name"/>
+            </xsl:call-template>
+          </xsl:variable>
+          <xsl:text>
+        public interface </xsl:text>
+          <xsl:value-of select="$spname"/>
+          <xsl:text> {</xsl:text>
+          <xsl:for-each select="enumeration/value">
+            <xsl:text>
+            int </xsl:text>
+            <xsl:value-of select="@const"/>
+            <xsl:text> = Constants.</xsl:text>
+            <xsl:value-of select="@const"/>
+            <xsl:text>;</xsl:text>
+          </xsl:for-each>
+          <xsl:text>
+        }</xsl:text>
+        </xsl:for-each>
+        <xsl:text>
+    }</xsl:text>
+      </xsl:if>
 
 
-<!-- Handle enumeration values -->
-<xsl:for-each select="enumeration/value">
-  protected final static EnumProperty s_prop<xsl:value-of select="@const"/> = new EnumProperty(<xsl:if test="../../@type='generic'">Enums.</xsl:if><xsl:value-of select="@const"/>);
-</xsl:for-each>
+      <!-- Handle enumeration values -->
+      <xsl:for-each select="enumeration/value">
+        <xsl:text>
+    protected final static EnumProperty s_prop</xsl:text>
+        <xsl:value-of select="@const"/>
+        <xsl:text> = new EnumProperty(</xsl:text>
+        <xsl:if test="../../@type='generic'">
+          <xsl:text>Enums.</xsl:text>
+        </xsl:if>
+        <xsl:value-of select="@const"/>
+        <xsl:text>);</xsl:text>
+      </xsl:for-each>
 
 
-<!-- Look for compound properties -->
-<xsl:if test="compound">
-      <xsl:variable name="enumclass">
-      <xsl:choose>
-        <xsl:when test="@type='generic'">Enums</xsl:when>
-        <xsl:otherwise><xsl:value-of select="$eclassname"/></xsl:otherwise>
-      </xsl:choose>
-      </xsl:variable>
-    <xsl:for-each select="compound/subproperty">
-      <xsl:variable name="spname">
-  <xsl:call-template name="makeClassName">
-          <xsl:with-param name="propstr" select="name"/>
-        </xsl:call-template>
-      </xsl:variable>
-      <xsl:variable name="sp_superclass">
-        <xsl:choose>
-          <xsl:when test="use-generic">
-            <xsl:value-of select="use-generic"/>
-          </xsl:when>
-          <xsl:otherwise>
-            <xsl:value-of select="datatype"/><xsl:text>Property.Maker</xsl:text>
-          </xsl:otherwise>
-        </xsl:choose>
-      </xsl:variable>
+      <!-- Look for compound properties -->
+      <xsl:if test="compound">
+        <xsl:variable name="enumclass">
+          <xsl:choose>
+            <xsl:when test="@type='generic'">
+              <xsl:text>Enums</xsl:text>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:value-of select="$eclassname"/>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:variable>
+        <xsl:for-each select="compound/subproperty">
+          <xsl:variable name="spname">
+            <xsl:call-template name="makeClassName">
+              <xsl:with-param name="propstr" select="name"/>
+            </xsl:call-template>
+          </xsl:variable>
+          <xsl:variable name="sp_superclass">
+            <xsl:choose>
+              <xsl:when test="use-generic">
+                <xsl:value-of select="use-generic"/>
+              </xsl:when>
+              <xsl:otherwise>
+                <xsl:value-of select="datatype"/>
+                <xsl:text>Property.Maker</xsl:text>
+              </xsl:otherwise>
+            </xsl:choose>
+          </xsl:variable>
+          
+          <xsl:choose>
+            <xsl:when test='*[local-name(.)!="name" and local-name(.)!="datatype" and local-name(.)!="use-generic" and local-name(.)!="default"]'>
+              <xsl:text>
+    static private class SP_</xsl:text>
+              <xsl:value-of select="$spname"/>
+              <xsl:text>Maker extends </xsl:text>
+              <xsl:value-of select="$sp_superclass"/>
+              <xsl:if test="enumeration">
+                <xsl:text> implements </xsl:text>
+                <xsl:value-of select="$enumclass"/>
+                <xsl:text>.</xsl:text>
+                <xsl:value-of select="$spname"/>
+              </xsl:if>
+              <xsl:text> {
+        SP_</xsl:text>
+              <xsl:value-of select="$spname"/>
+              <xsl:text>Maker(String sPropName) {
+            super(sPropName);
+        }</xsl:text>
+              <xsl:for-each select="enumeration/value">
+                <xsl:text>
+        protected final static EnumProperty s_prop</xsl:text>
+                <xsl:value-of select="@const"/>
+                <xsl:text> = new EnumProperty(</xsl:text>
+                <xsl:value-of select="@const"/>
+                <xsl:text>);</xsl:text>
+              </xsl:for-each>
+
+              <xsl:apply-templates
+                select="percent-ok|auto-ok|keyword-equiv|
+                        datatype-conversion|enumeration"/>
+              <xsl:text>
+    }
 
-      <xsl:choose>
-        <xsl:when test='*[local-name(.)!="name" and local-name(.)!="datatype" and local-name(.)!="use-generic" and local-name(.)!="default"]'>
-    static private class SP_<xsl:value-of select="$spname"/>Maker
-  extends <xsl:value-of select="$sp_superclass"/>
-<xsl:if test="enumeration"> implements <xsl:value-of select="$enumclass"/>.<xsl:value-of select="$spname"/></xsl:if> {
-  SP_<xsl:value-of select="$spname"/>Maker(String sPropName) {
-       super(sPropName);
-        }
-<xsl:for-each select="enumeration/value">
-       protected final static EnumProperty s_prop<xsl:value-of select="@const"/> = new EnumProperty(<xsl:value-of select="@const"/>);
-</xsl:for-each>
+    final private static Property.Maker s_</xsl:text>
+              <xsl:value-of select="$spname"/>
+              <xsl:text>Maker =
+              new SP_</xsl:text><xsl:value-of select="$spname"/>
+              <xsl:text>Maker("</xsl:text>
+              <xsl:value-of select='../../name'/>
+              <xsl:text>.</xsl:text>
+              <xsl:value-of select='name'/>
+              <xsl:text>");</xsl:text>
+            </xsl:when>
+            <xsl:otherwise>
+              <xsl:text>
+    final private static Property.Maker s_</xsl:text>
+              <xsl:value-of select="$spname"/>
+              <xsl:text>Maker =
+              new </xsl:text><xsl:value-of select="$sp_superclass"/>
+              <xsl:text>("</xsl:text>
+              <xsl:value-of select='../../name'/>
+              <xsl:text>.</xsl:text>
+              <xsl:value-of select='name'/>
+              <xsl:text>");</xsl:text>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:for-each>
+      </xsl:if>
 
-  <xsl:apply-templates select="percent-ok|auto-ok|keyword-equiv|datatype-conversion|enumeration"/>
-    }
-    final private static Property.Maker s_<xsl:value-of select="$spname"/>Maker =
-  new SP_<xsl:value-of select="$spname"/>Maker(
-       "<xsl:value-of select='../../name'/>.<xsl:value-of select='name'/>");
-        </xsl:when>
-        <xsl:otherwise>
-    final private static Property.Maker s_<xsl:value-of select="$spname"/>Maker =
-  new <xsl:value-of select="$sp_superclass"/>(
-       "<xsl:value-of select='../../name'/>.<xsl:value-of select='name'/>");
-  </xsl:otherwise>
-      </xsl:choose>
-    </xsl:for-each>
-</xsl:if>
+      <xsl:text>
 
     static public Property.Maker maker(String propName) {
-  return new <xsl:value-of select="$classname"/>(propName);
+        return new </xsl:text>
+      <xsl:value-of select="$classname"/>
+      <xsl:text>(propName);
     }
 
-    protected <xsl:value-of select="$classname"/>(String name) {
-  super(name);
-<xsl:if test="compound">
-        m_shorthandMaker= getSubpropMaker("<xsl:value-of select='compound/subproperty[@set-by-shorthand="true"]/name'/>");
-</xsl:if>
+    protected </xsl:text>
+      <xsl:value-of select="$classname"/>
+      <xsl:text>(String name) {
+        super(name);</xsl:text>
+      <xsl:if test="compound">
+        <xsl:text>
+        m_shorthandMaker= getSubpropMaker("</xsl:text>
+        <xsl:value-of select=
+            'compound/subproperty[@set-by-shorthand="true"]/name'/>
+        <xsl:text>");</xsl:text>
+      </xsl:if>
+      <xsl:text>
     }
+</xsl:text>
 
-<xsl:if test="compound">
+      <xsl:if test="compound">
+        <xsl:text>
     Property.Maker m_shorthandMaker;
 
     public Property checkEnumValues(String value) {
-  return m_shorthandMaker.checkEnumValues(value);
+        return m_shorthandMaker.checkEnumValues(value);
     }
 
     protected boolean isCompoundMaker() {
-      return true;
+        return true;
     }
 
-    protected Property.Maker getSubpropMaker(String subprop) {
-    <xsl:for-each select="compound/subproperty">
-      <xsl:variable name="spname">
-  <xsl:call-template name="makeClassName">
-          <xsl:with-param name="propstr" select="name"/>
-        </xsl:call-template>
-      </xsl:variable>
-  if (subprop.equals("<xsl:value-of select='name'/>"))
-    return s_<xsl:value-of select="$spname"/>Maker;
-    </xsl:for-each>
-  return super.getSubpropMaker(subprop);
+    protected Property.Maker getSubpropMaker(String subprop) {</xsl:text>
+        <xsl:for-each select="compound/subproperty">
+          <xsl:variable name="spname">
+            <xsl:call-template name="makeClassName">
+              <xsl:with-param name="propstr" select="name"/>
+            </xsl:call-template>
+          </xsl:variable>
+          <xsl:text>
+        if (subprop.equals("</xsl:text>
+          <xsl:value-of select='name'/>
+          <xsl:text>"))
+            return s_</xsl:text>
+          <xsl:value-of select="$spname"/>
+          <xsl:text>Maker;</xsl:text>
+        </xsl:for-each>
+        <xsl:text>
+        return super.getSubpropMaker(subprop);
     }
 
     protected Property setSubprop(Property baseProp, String subpropName,
-  Property subProp) {
-        <xsl:value-of select="datatype"/> val = baseProp.get<xsl:value-of select="datatype"/>();
-  // Do some type checking???
-  // Check if one of our subproperties???
-  val.setComponent(subpropName, subProp, false);
-  return baseProp;
+                                  Property subProp) {
+        </xsl:text>
+        <xsl:value-of select="datatype"/>
+        <xsl:text> val = baseProp.get</xsl:text>
+        <xsl:value-of select="datatype"/>
+        <xsl:text>();
+        // Do some type checking???
+        // Check if one of our subproperties???
+        val.setComponent(subpropName, subProp, false);
+        return baseProp;
     }
 
     public Property getSubpropValue(Property baseProp, String subpropName) {
-      <xsl:value-of select="datatype"/> val = baseProp.get<xsl:value-of select="datatype"/>();
-      return val.getComponent(subpropName);
+        </xsl:text>
+        <xsl:value-of select="datatype"/>
+        <xsl:text> val = baseProp.get</xsl:text>
+        <xsl:value-of select="datatype"/>
+        <xsl:text>();
+        return val.getComponent(subpropName);
     }
-<xsl:choose>
-<!-- some subproperty default is context dependent; don't cache default! -->
-<xsl:when test='.//default[@contextdep="true"]'>
+</xsl:text>
+      <xsl:choose>
+        <!-- some subproperty default is context dependent;
+             don't cache default! -->
+        <xsl:when test='.//default[@contextdep="true"]'>
+          <xsl:text>
     public Property make(PropertyList propertyList) throws FOPException {
         return makeCompound(propertyList, propertyList.getParentFObj());
-    }
-</xsl:when>
-<xsl:otherwise>
+    }</xsl:text>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:text>
     private Property m_defaultProp=null;
     public Property make(PropertyList propertyList) throws FOPException {
         if (m_defaultProp == null) {
-            m_defaultProp=makeCompound(propertyList, propertyList.getParentFObj());
-  }
+            m_defaultProp=makeCompound(
+                            propertyList, propertyList.getParentFObj());
+        }
         return m_defaultProp;
-    }
-</xsl:otherwise>
-</xsl:choose>
-
-    protected Property makeCompound(PropertyList pList, FObj fo) throws FOPException {
-  <xsl:value-of select="datatype"/> p = new <xsl:value-of select="datatype"/>();
-  Property subProp;
-    <xsl:for-each select="compound/subproperty/name">
-      <xsl:variable name="spname">
-  <xsl:call-template name="makeClassName">
-    <xsl:with-param name="propstr" select="."/>
-  </xsl:call-template>
-      </xsl:variable>
-   // set default for subprop <xsl:value-of select="."/>
-   subProp = getSubpropMaker("<xsl:value-of select='.'/>").make(pList,
-    getDefaultFor<xsl:value-of select='$spname'/>(), fo);
-    p.setComponent("<xsl:value-of select='.'/>", subProp, true);
-    </xsl:for-each>
-  return new <xsl:value-of select="$propclass"/>(p);
-    }
-
-    <!-- generate a "getDefaultForXXX" for each subproperty XXX -->
-    <xsl:for-each select="compound/subproperty">
-      <xsl:variable name="spname">
-  <xsl:call-template name="makeClassName">
-    <xsl:with-param name="propstr" select="name"/>
-  </xsl:call-template>
-      </xsl:variable>
-    protected String getDefaultFor<xsl:value-of  select='$spname'/>() {
-      <xsl:choose><xsl:when test="default">
-  return "<xsl:value-of  select='default'/>";
-        </xsl:when><xsl:when test="use-generic and key('genericref', use-generic)/default">
-  return "<xsl:value-of select='key(&apos;genericref&apos;, use-generic)/default'/>";
-        </xsl:when><xsl:otherwise>
-  return "";
-  </xsl:otherwise>
+    }</xsl:text>
+        </xsl:otherwise>
       </xsl:choose>
+      <xsl:text>
+
+    protected Property makeCompound(PropertyList pList, FObj fo) throws FOPException {</xsl:text>
+      <xsl:value-of select="datatype"/>
+      <xsl:text> p = new </xsl:text>
+      <xsl:value-of select="datatype"/>
+      <xsl:text>();
+        Property subProp;</xsl:text>
+      <xsl:for-each select="compound/subproperty/name">
+        <xsl:variable name="spname">
+          <xsl:call-template name="makeClassName">
+            <xsl:with-param name="propstr" select="."/>
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:text>
+       // set default for subprop </xsl:text>
+        <xsl:value-of select="."/>
+        <xsl:text>
+          subProp = getSubpropMaker("</xsl:text>
+        <xsl:value-of select='.'/>
+        <xsl:text>").make(pList, getDefaultFor</xsl:text>
+        <xsl:value-of select='$spname'/>
+        <xsl:text>(), fo);
+          p.setComponent("</xsl:text>
+        <xsl:value-of select='.'/>
+        <xsl:text>", subProp, true);</xsl:text>
+      </xsl:for-each>
+      <xsl:text>
+        return new </xsl:text>
+      <xsl:value-of select="$propclass"/>
+      <xsl:text>(p);
     }
-    </xsl:for-each>
+</xsl:text>
+      <!-- generate a "getDefaultForXXX" for each subproperty XXX -->
+      <xsl:for-each select="compound/subproperty">
+        <xsl:variable name="spname">
+          <xsl:call-template name="makeClassName">
+            <xsl:with-param name="propstr" select="name"/>
+          </xsl:call-template>
+        </xsl:variable>
+        <xsl:text>
+        protected String getDefaultFor</xsl:text>
+        <xsl:value-of  select='$spname'/>
+        <xsl:text>() {</xsl:text>
+        <xsl:choose>
+          <xsl:when test="default">
+            <xsl:text>
+            return "</xsl:text>
+            <xsl:value-of  select='default'/>
+            <xsl:text>";</xsl:text>
+          </xsl:when>
+          <xsl:when test=
+            "use-generic and key('genericref', use-generic)/default">
+            <xsl:text>
+            return "</xsl:text>
+            <xsl:value-of select='key(&apos;genericref&apos;,
+                                  use-generic)/default'/>
+            <xsl:text>";</xsl:text>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:text>
+            return "";</xsl:text>
+          </xsl:otherwise>
+        </xsl:choose>
+        <xsl:text>
+    }</xsl:text>
+      </xsl:for-each>
+      <xsl:text>
 
     /** Set the appropriate components when the "base" property is set. */
     public Property convertProperty(Property p, PropertyList pList,FObj fo)
-  throws FOPException
-    {
-        if (p instanceof <xsl:value-of select="$propclass"/>) return p;
-  if (! (p instanceof EnumProperty)) {
-    // delegate to the subprop maker to do conversions
-    p = m_shorthandMaker.convertProperty(p,pList,fo);
-        }
-  if (p != null) {
-    Property prop = makeCompound(pList, fo);
-
-    <xsl:value-of select="datatype"/> pval = prop.get<xsl:value-of select="datatype"/>();
-<xsl:for-each select="compound/subproperty[@set-by-shorthand='true']">
-    pval.setComponent("<xsl:value-of select='name'/>", p, false);
-</xsl:for-each>
-          return prop;
+            throws FOPException {
+        if (p instanceof </xsl:text>
+      <xsl:value-of select="$propclass"/>
+      <xsl:text>) return p;
+        if (! (p instanceof EnumProperty)) {
+            // delegate to the subprop maker to do conversions
+            p = m_shorthandMaker.convertProperty(p,pList,fo);
         }
-  else return null;
-<!--
-        else {
-    // throw some kind of exception!
-    throw new FOPException("Can't convert value to <xsl:value-of select='$spdt'/> type");
+        if (p != null) {
+            Property prop = makeCompound(pList, fo);
+      </xsl:text>
+      <xsl:value-of select="datatype"/>
+      <xsl:text> pval = prop.get</xsl:text>
+      <xsl:value-of select="datatype"/>
+      <xsl:text>();</xsl:text>
+      <xsl:for-each select="compound/subproperty[@set-by-shorthand='true']">
+        <xsl:text>
+            pval.setComponent("</xsl:text>
+        <xsl:value-of select='name'/>
+        <xsl:text>", p, false);</xsl:text>
+      </xsl:for-each>
+      <xsl:text>
+            return prop;
         }
--->
+        else return null;</xsl:text>
+        <!--
+             else {
+             // throw some kind of exception!
+             throw new FOPException("Can't convert value to <xsl:value-of select='$spdt'/> type");
+             }
+         -->
+      <xsl:text>
     }
 
-</xsl:if> <!-- property/compound -->
+</xsl:text>
+      </xsl:if> <!-- property/compound -->
 
-<xsl:if test="inherited">
-   public boolean isInherited() { return <xsl:value-of select="inherited"/>; }
-</xsl:if>
+      <xsl:if test="inherited">
+        <xsl:text>
+    public boolean isInherited() {
+          return </xsl:text>
+        <xsl:value-of select="inherited"/>
+        <xsl:text>;
+    }
+</xsl:text>
+      </xsl:if>
 
-<!-- the default implementation returns false -->
-<xsl:if test='inherited/@type="specified"'>
-   public boolean inheritsSpecified() {
-   return true;
-   }
-</xsl:if>
+      <!-- the default implementation returns false -->
+      <xsl:if test='inherited/@type="specified"'>
+        <xsl:text>
+    public boolean inheritsSpecified() {
+        return true;
+    }
+</xsl:text>
+      </xsl:if>
 
 
-<!-- Currently only works for Enum values -->
-<xsl:if test="derive">
+      <!-- Currently only works for Enum values -->
+      <xsl:if test="derive">
+        <xsl:text>
     public Property compute(PropertyList propertyList) {
-      Property computedProperty = null;
-      Property correspondingProperty = propertyList.get("<xsl:value-of select="derive/@from"/>");
-      if (correspondingProperty != null) {
-        int correspondingValue = correspondingProperty.getEnum();
+        Property computedProperty = null;
+        Property correspondingProperty = propertyList.get("</xsl:text>
+        <xsl:value-of select="derive/@from"/>
+        <xsl:text>");
+        if (correspondingProperty != null) {
+            int correspondingValue = correspondingProperty.getEnum();</xsl:text>
         <xsl:for-each select="derive/if">
-        if (correspondingValue == <xsl:value-of select="@match"/>)
-          computedProperty = new EnumProperty(<xsl:value-of select="."/>);
-        else</xsl:for-each>
-        ;
-      }
-      return computedProperty;
+          <xsl:text>
+            if (correspondingValue == </xsl:text>
+          <xsl:value-of select="@match"/>
+          <xsl:text>)
+                computedProperty = new EnumProperty(</xsl:text>
+          <xsl:value-of select="."/>
+          <xsl:text>);
+            else</xsl:text>
+        </xsl:for-each>
+        <xsl:text>
+                ;
+        }
+        return computedProperty;
     }
-</xsl:if>
+</xsl:text>
+      </xsl:if>
 
-<!-- If any corresponding element at property or subproperty levels -->
-<xsl:if test=".//corresponding">
-    <xsl:if test=".//corresponding/@use-if-specified='true'">
+      <!-- If any corresponding element at property or subproperty levels -->
+      <xsl:if test=".//corresponding">
+        <xsl:if test=".//corresponding/@use-if-specified='true'">
+          <xsl:text>
     public boolean isCorrespondingForced(PropertyList propertyList) {
-      FObj parentFO = propertyList.getParentFObj();
-      StringBuffer sbExpr=new StringBuffer();
-      <xsl:for-each select=".//corresponding/propval">
-      sbExpr.setLength(0);
-      <xsl:apply-templates select="."/>
-      if (propertyList.getExplicit(sbExpr.toString()) != null) return true;
-      </xsl:for-each>
-      return false;
+        FObj parentFO = propertyList.getParentFObj();
+        StringBuffer sbExpr=new StringBuffer();</xsl:text>
+          <xsl:for-each select=".//corresponding/propval">
+            <xsl:text>
+        sbExpr.setLength(0);</xsl:text>
+            <xsl:apply-templates select="."/>
+            <xsl:text>
+        if (propertyList.getExplicit(sbExpr.toString()) != null)
+            return true;</xsl:text>
+          </xsl:for-each>
+          <xsl:text>
+        return false;
     }
-    </xsl:if>
+</xsl:text>
+      </xsl:if>
+      <xsl:text>
 
     public Property compute(PropertyList propertyList) throws FOPException {
-      FObj parentFO = propertyList.getParentFObj();
-      StringBuffer sbExpr=new StringBuffer();
-      Property p=null;
-      <xsl:choose><xsl:when test="corresponding/propexpr">
-      <xsl:apply-templates select="corresponding/propval"/>
-  // Make sure the property is set before calculating it!
-      if (propertyList.getExplicitOrShorthand(sbExpr.toString()) == null) return p;
-      sbExpr.setLength(0);
-      <xsl:apply-templates select="corresponding/propexpr"/>
-      p= make(propertyList, sbExpr.toString(), propertyList.getParentFObj());
-      </xsl:when><xsl:otherwise>
-      <xsl:apply-templates select="corresponding/propval"/>
-      p= propertyList.getExplicitOrShorthand(sbExpr.toString());
-      </xsl:otherwise></xsl:choose>
-      if (p != null) {
-          p = convertProperty(p, propertyList, parentFO );
-      }
+        FObj parentFO = propertyList.getParentFObj();
+        StringBuffer sbExpr=new StringBuffer();
+        Property p=null;</xsl:text>
+      <xsl:choose>
+        <xsl:when test="corresponding/propexpr">
+          <xsl:apply-templates select="corresponding/propval"/>
+          <xsl:text>
+        // Make sure the property is set before calculating it!
+        if (propertyList.getExplicitOrShorthand(sbExpr.toString()) == null)
+            return p;
+        sbExpr.setLength(0);</xsl:text>
+          <xsl:apply-templates select="corresponding/propexpr"/>
+          <xsl:text>
+        p = make(propertyList, sbExpr.toString(), propertyList.getParentFObj());</xsl:text>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:apply-templates select="corresponding/propval"/>
+          <xsl:text>
+        p= propertyList.getExplicitOrShorthand(sbExpr.toString());</xsl:text>
+        </xsl:otherwise>
+      </xsl:choose>
+      <xsl:text>
+        if (p != null) {
+            p = convertProperty(p, propertyList, parentFO );
+        }</xsl:text>
       <xsl:if test="compound">
-      else p= makeCompound(propertyList, parentFO);
-
-      Property subprop;
-      <xsl:for-each select="compound/subproperty/corresponding">
-      sbExpr.setLength(0);
-      <xsl:choose><xsl:when test="propexpr">
-      <xsl:apply-templates select="propexpr"/>
-      subprop= getSubpropMaker("<xsl:value-of select='../name'/>").
-          make(propertyList, sbExpr.toString(), parentFO);
-      </xsl:when><xsl:otherwise>
-      <xsl:apply-templates select="propval"/>
-      subprop= propertyList.getExplicitOrShorthand(sbExpr.toString());
-      </xsl:otherwise></xsl:choose>
-      if (subprop != null) {
-        setSubprop(p, "<xsl:value-of select='../name'/>", subprop);
-      }
+        <xsl:text>
+        else p = makeCompound(propertyList, parentFO);
+
+        Property subprop;</xsl:text>
+        <xsl:for-each select="compound/subproperty/corresponding">
+          <xsl:text>
+        sbExpr.setLength(0);</xsl:text>
+          <xsl:choose>
+            <xsl:when test="propexpr">
+              <xsl:apply-templates select="propexpr"/>
+              <xsl:text>
+        subprop = getSubpropMaker("</xsl:text>
+              <xsl:value-of select='../name'/>
+              <xsl:text>").
+                  make(propertyList, sbExpr.toString(), parentFO);</xsl:text>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:apply-templates select="propval"/>
+            <xsl:text>
+        subprop = propertyList.getExplicitOrShorthand(sbExpr.toString());</xsl:text>
+          </xsl:otherwise>
+        </xsl:choose>
+        <xsl:text>
+        if (subprop != null) {
+            setSubprop(p, "</xsl:text>
+        <xsl:value-of select='../name'/>
+        <xsl:text>", subprop);
+        }</xsl:text>
       </xsl:for-each>
-      </xsl:if>
-      return p;
+    </xsl:if>
+    <xsl:text>
+        return p;
     }
+</xsl:text>
 </xsl:if>
 
 <!-- If can be specified by any shorthand property -->
 <xsl:if test="shorthand">
+  <xsl:text>
     public Property getShorthand(PropertyList propertyList) {
-      Property p = null;
-      ListProperty listprop;
-      <xsl:for-each select="shorthand">
-  <xsl:variable name="shprop" select="."/>
-      if (p == null) {
-         listprop = (ListProperty)propertyList.getExplicit("<xsl:value-of select='$shprop'/>");
-         if (listprop != null) {
-           // Get a parser for the shorthand to set the individual properties
-           ShorthandParser shparser = new <xsl:value-of select="key('shorthandref', $shprop)/datatype-parser"/>(listprop);
-             p = shparser.getValueForProperty(getPropName(), this, propertyList);
-         }
-      }
-      </xsl:for-each>
-      return p;
+        Property p = null;
+        ListProperty listprop;</xsl:text>
+  <xsl:for-each select="shorthand">
+    <xsl:variable name="shprop" select="."/>
+    <xsl:text>
+        if (p == null) {
+            listprop =
+                (ListProperty)propertyList.getExplicit("</xsl:text>
+    <xsl:value-of select='$shprop'/>
+    <xsl:text>");
+            if (listprop != null) {
+               // Get a parser for the shorthand to set the individual properties
+               ShorthandParser shparser =
+                      new </xsl:text>
+    <xsl:value-of select="key('shorthandref', $shprop)/datatype-parser"/>
+    <xsl:text>(listprop);
+               p = shparser.getValueForProperty(
+                                        getPropName(), this, propertyList);
+            }
+        }</xsl:text>
+  </xsl:for-each>
+  <xsl:text>
+        return p;
     }
+</xsl:text>
 </xsl:if>
 
-<xsl:apply-templates select="percent-ok|auto-ok|default|keyword-equiv|datatype-conversion|enumeration|extfile"/>
+<xsl:apply-templates select=
+      "percent-ok|auto-ok|default|keyword-equiv|datatype-conversion|
+            enumeration|extfile"/>
+<xsl:text>
 }
+</xsl:text>
 </redirect:write>
 </xsl:if> <!-- need to create a class -->
 </xsl:template>
 
 <xsl:template match="corresponding/propexpr/propval">
-   sbExpr.append("_fop-property-value("); <!-- Note: interpreted by property parser -->
-   <xsl:apply-templates/>
-   sbExpr.append(")");
+  <xsl:text>
+        sbExpr.append("_fop-property-value(");</xsl:text> <!-- Note: interpreted by property parser -->
+  <xsl:apply-templates/>
+  <xsl:text>
+        sbExpr.append(")");</xsl:text>
 </xsl:template>
 
 
 <xsl:template match="corresponding//text()">
-   <xsl:variable name="tval" select='normalize-space(.)'/>
-   <xsl:if test="$tval != ''">sbExpr.append("<xsl:value-of select='$tval'/>");</xsl:if>
+  <xsl:variable name="tval" select='normalize-space(.)'/>
+  <xsl:if test="$tval != ''">
+    <xsl:text>
+        sbExpr.append("</xsl:text>
+    <xsl:value-of select='$tval'/>
+    <xsl:text>");</xsl:text>
+  </xsl:if>
 </xsl:template>
 
 <xsl:template match="propval/wmrel2abs">
-   sbExpr.append(propertyList.wmRelToAbs(PropertyList.<xsl:value-of select="@dir"/>));
+  <xsl:text>
+        sbExpr.append(propertyList.wmRelToAbs(PropertyList.</xsl:text>
+  <xsl:value-of select="@dir"/>
+  <xsl:text>));</xsl:text>
 </xsl:template>
 
 <xsl:template match="propval/parwmrel2abs">
-   sbExpr.append(parentFO.properties.wmRelToAbs(PropertyList.<xsl:value-of select="@dir"/>));
+  <xsl:text>
+        sbExpr.append(parentFO.properties.wmRelToAbs(PropertyList.</xsl:text>
+  <xsl:value-of select="@dir"/>
+  <xsl:text>));</xsl:text>
 </xsl:template>
 
 <xsl:template match="propval/wmabs2rel">
-   sbExpr.append(propertyList.wmAbsToRel(PropertyList.<xsl:value-of select="@dir"/>));
+  <xsl:text>
+        sbExpr.append(propertyList.wmAbsToRel(PropertyList.</xsl:text>
+  <xsl:value-of select="@dir"/>
+  <xsl:text>));</xsl:text>
 </xsl:template>
 
 <!-- avoid unwanted output to placeholder file -->
@@ -619,31 +915,40 @@ public class <xsl:value-of select="$classname"/> extends  <xsl:value-of select="
      from the first member. Return the first member.
  -->
 <xsl:template name="check-subprop-datatype">
-    <xsl:param name="dtlist"/>
-    <xsl:variable name="dt"><xsl:value-of select='$dtlist[1]'/></xsl:variable>
-    <xsl:for-each select="$dtlist">
-  <xsl:if test=". != $dt">
+  <xsl:param name="dtlist"/>
+  <xsl:variable name="dt">
+    <xsl:value-of select='$dtlist[1]'/>
+  </xsl:variable>
+  <xsl:for-each select="$dtlist">
+    <xsl:if test=". != $dt">
       <xsl:message>
-          <xsl:text>Conflict between subproperty datatypes: </xsl:text>
-    <xsl:value-of select='.'/> != <xsl:value-of select='$dt'/>
+        <xsl:text>Conflict between subproperty datatypes: </xsl:text>
+        <xsl:value-of select='.'/> != <xsl:value-of select='$dt'/>
       </xsl:message>
-  </xsl:if>
-    </xsl:for-each>
-    <xsl:value-of select='$dt'/>
+    </xsl:if>
+  </xsl:for-each>
+  <xsl:value-of select='$dt'/>
 </xsl:template>
 
 <!-- If the value of an enumeration constant contains two or more words,
      separated by a blank, map all of these words to the same constant.
 -->
 <xsl:template name="enumvals">
-   <xsl:param name="specvals"/>
-   <xsl:if test='string-length($specvals)>0'>
-   <xsl:variable name="oneval" select="substring-before($specvals, ' ')"/>
-      if (value.equals("<xsl:value-of select="$oneval"/>")) { return s_prop<xsl:value-of select="@const"/>; }
+  <xsl:param name="specvals"/>
+  <xsl:if test='string-length($specvals)>0'>
+    <xsl:variable name="oneval" select="substring-before($specvals, ' ')"/>
+    <xsl:text>
+        if (value.equals("</xsl:text>
+    <xsl:value-of select="$oneval"/>
+    <xsl:text>")) {
+            return s_prop</xsl:text>
+    <xsl:value-of select="@const"/>
+    <xsl:text>;
+        }</xsl:text>
     <xsl:call-template name="enumvals">
-       <xsl:with-param name="specvals" select="substring-after($specvals, ' ')"/>
+      <xsl:with-param name="specvals" select="substring-after($specvals, ' ')"/>
     </xsl:call-template>
-    </xsl:if>
+  </xsl:if>
 </xsl:template>
 
 </xsl:stylesheet>